पहेली स्क्रिप्ट पर पहेली खेल बनाना

एचटीएमएल 5 के लिए पहेली बनाने के लिए पहेली स्क्रिप्ट एक न्यूनतर गेम इंजन है, इसमें ओपन सोर्स हैं। तैयार खेलों के उदाहरण यहां देखे जा सकते हैं ।

भाग 1. हम पहेली स्क्रिप्ट पर पहला गेम बनाते हैं।

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


इंजन की वेबसाइट पर जाएं। पहेली स्क्रिप्ट संपादक को खोलने के लिए एक गेम बनाएं पर क्लिक करें ।

डाउनलोडिंग उदाहरण

आरंभ करने के लिए, आइए कुछ उदाहरण देखें। स्क्रीन के शीर्ष पर, "लोड उदाहरण" सूची खोलें और "बेसिक" नामक पहला उदाहरण चुनें। अब "रन" पर क्लिक करें।



गेम स्क्रीन दिखाई देगी। इसकी विंडो के अंदर क्लिक करें और कीबोर्ड पर एंटर दबाएं।


खेल खेलने की कोशिश करो। आपका लक्ष्य नारंगी बक्से को काले लक्ष्य वर्गों में धकेलना है। जब प्रत्येक लक्ष्य पर एक बॉक्स होगा, तो स्तर पारित हो जाएगा। आप इस कदम को रद्द करने के लिए Z दबा सकते हैं, या R स्तर को पुनः आरंभ करने के लिए।

पहला गेम बनाओ

अब हम कई स्तर बनाएंगे। मैं तुम्हारे साथ एक बनाऊंगा, और मैं दूसरों को अपने साथ आने की सलाह देता हूं। शीर्ष मेनू में "स्तर संपादक" पर क्लिक करें।


यदि आप स्तर संपादक स्क्रीन नहीं देखते हैं, तो "रन" पर क्लिक करें और खेल शुरू करें। एक बार स्तर पर, फिर से "स्तर संपादक" बटन पर क्लिक करें। यह आपको उस स्तर को संपादित करने की अनुमति देगा, जिस पर आप बस थे।

एक नया स्तर बनाएं

शीर्ष पर खेल की वस्तुएं हैं। जब बाईं ओर क्लिक किया जाता है, तो चयनित वस्तु खींची जाती है। राइट क्लिक एक "पृष्ठभूमि" ऑब्जेक्ट खींचता है। मैप के किनारे पर लेफ्ट-क्लिक करने से इसका आकार बढ़ जाता है, राइट-क्लिक करने से यह कम हो जाता है।


एक स्तर पास करने के लिए, आपको प्रत्येक लक्ष्य पर एक बॉक्स लगाने की जरूरत है, इसलिए प्रत्येक स्तर पर एक न्यूनतम होना चाहिए:

• 1 बॉक्स
• 1 गोल
• 1 खिलाड़ी

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

इसे स्तरों की सूची में जोड़ें।

स्तर बनाने के बाद, हम इसे स्तरों की सूची में जोड़ देंगे। स्तर संपादक में, बनाए गए स्तर को बचाने के लिए गेम ऑब्जेक्ट्स की सूची के बगल में सफेद अक्षर S पर क्लिक करें।


सफल संकलन के बारे में एक संदेश और मजेदार पात्रों की एक ग्रिड को स्तर संपादक के नीचे प्रदर्शित किया जाना चाहिए, जैसा कि नीचे दिखाया गया है।


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

। = पृष्ठभूमि
# = दीवार
पी = खिलाड़ी
* = टोकरा
@ = टोकरा और निशाना
ओ = लक्ष्य

स्क्रीन के बाईं ओर जो कुछ है, वह गेम कोड है, जिसे विभिन्न भागों में विभाजित किया गया है, जैसे OBJECTS या LEGEND। नीचे जाने के लिए स्तर। यहां हम उन स्तरों को देखते हैं जो उदाहरण में उपयोग किए जाते हैं।


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


हम इसका परीक्षण करेंगे। एक नया स्तर बनाने के बाद, आपको एक नए स्तर के साथ गेम को पुनरारंभ करने के लिए फिर से स्क्रीन के शीर्ष पर "रन" बटन को दबाने की आवश्यकता है। कभी-कभी यह काम नहीं करता है, और फिर आपको "पुनर्निर्माण" बटन पर क्लिक करने की आवश्यकता है, और फिर "रन" पर फिर से क्लिक करें।

किसी गेम को सहेजना और लोड करना

कुछ और नए स्तर बनाने की कोशिश करें। जब आप गेम को सहेजने के लिए तैयार हों, तो कोड की शुरुआत तक जाएं और अपना नाम, लेखक का नाम और होम पेज दर्ज करें, और फिर "सहेजें" बटन पर क्लिक करें।



आपके कंप्यूटर पर "लोड" मेनू में सीमित संख्या में बचत होती है। हालाँकि, स्क्रीन के शीर्ष पर एक “शेयर” बटन है। जब आप उस पर क्लिक करते हैं, तो दो वेब लिंक वाला संदेश उत्पन्न होता है।


लिंक में से एक आपकी परियोजना का स्रोत कोड है। दूसरा गेम के खेलने योग्य संस्करण का एक लिंक है जिसे आप दोस्तों के साथ साझा कर सकते हैं। मैं समय-समय पर स्रोत कोड के लिए एक नया लिंक बनाने और इसे एक पाठ दस्तावेज़ में सहेजने की सलाह देता हूं ताकि आपके पास परियोजना का स्थायी रूप से संग्रहीत संस्करण हो।

खेल निर्यात

आप गेम को HTML5 फ़ाइल के रूप में भी निर्यात कर सकते हैं, जिसे आप गेम पोर्टल्स, जैसे कि itch.io , Kongregate, या Newgrounds में अपलोड कर सकते हैं। बस "निर्यात" पर क्लिक करें और डाउनलोड की गई HTML फ़ाइल को गेम पोर्टल पर अपलोड करें।

हमारे नमूना परियोजना यहाँ पाया जा सकता है ।

भाग 2. पहेली स्क्रिप्ट में आरंभ करना

इस भाग में, हम सीखेंगे कि पहेली स्क्रिप्ट में प्रोग्रामिंग कैसे शुरू करें।

कोड

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

[ > Player | Crate ] -> [ > Player | > Crate ]

इस पंक्ति का अर्थ है कि यदि खिलाड़ी बॉक्स के पास है और अपनी दिशा में आगे बढ़ता है, तो खेल खिलाड़ी को स्थानांतरित करता है और बॉक्स को धक्का देता है। यह समझने के लिए कि यह कैसे काम करता है, आपको यह समझने की आवश्यकता है कि पहेली स्क्रिप्ट कोड इस संरचना का अनुसरण करता है:

[ ] -> [ ]

इसका मतलब निम्न है:

[ ] -> [ ]

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

स्थितियों के उदाहरण

यहाँ एक शर्त का एक उदाहरण है:

[ object1 | object2 ]

यह घटना जांचती है कि क्या ऑब्जेक्ट 1 ऑब्जेक्ट 2 के बगल में है। आप जाँच सकते हैं कि क्या दो वस्तुएं एक | रखकर एक दूसरे के बगल में हैं | शिफ्ट + \ _ दबाकर दर्ज की गई | । परिस्थितियाँ हमेशा [ ] में संलग्न होती [ ] ।

[ crate | crate ]

उपरोक्त कोड यह देखने के लिए जांचता है कि क्या दो बॉक्स एक दूसरे के बगल में हैं।

[ crate | crate | crate ]

यह स्थिति जांचती है कि तीन बॉक्स पास में हैं या नहीं।

[ crate target ]

यह स्थिति चेक करती है कि बॉक्स लक्ष्य के शीर्ष पर है क्योंकि | दो वस्तुओं के बीच | । ऑब्जेक्ट एक-दूसरे के शीर्ष पर हो सकते हैं यदि वे टकराव की विभिन्न परतों में स्थित हैं, जिसे हम ट्यूटोरियल के निम्नलिखित हिस्सों में कवर करेंगे।

हम समानता रखते हैं

नियमों को संतुलित होना चाहिए। दोनों हालत की जांच और इसके बाद की घटना को उसी तरह वर्णित किया जाना चाहिए। मैं दिखाऊंगा कि इसका क्या मतलब है।

[ player | crate ] -> [ player | ]

कोड की यह पंक्ति बॉक्स को नष्ट कर देती है यदि खिलाड़ी इसके बगल में है। आप नहीं लिख सकते:

[ player | crate ] -> [ player ]

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

[ | ] -> [ | ]

[ player | crate ] -> [ player | ]

यानी कोड पदार्थ में रिक्त स्थान भी। हालाँकि, निम्न प्रविष्टि मान्य है:

[ player target ] -> [ player ]

चूंकि जिस हालत में हम केवल एक ग्रिड स्थान के बारे में बात कर रहे हैं, घटना उसी ग्रिड स्थान का वर्णन करती है।

बक्से कैसे स्थानांतरित करें

कोड की मूल पंक्ति पर वापस चलते हैं।

[ > Player | Crate ] -> [ > Player | > Crate ]

दूसरे शब्दों में:

[ | ] -> [ | ]

एरो> आंदोलन पर जोर देता है।

कभी-कभी हमें कोड को याद रखने के लिए टिप्पणियों को लिखने की आवश्यकता होती है। पहेली स्क्रिप्ट टिप्पणियों को अनदेखा करती है - वे केवल उपयोगकर्ता के लिए हैं। एक टिप्पणी लिखने के लिए, आपको पाठ को कोष्ठक में रखना होगा। हम अपने नियम पर एक टिप्पणी लिखते हैं जो यह बताता है कि यह क्या करता है:

( )
[ > Player | Crate ] -> [ > Player | > Crate ]

अब, बॉक्स धक्का कोड के तहत, निम्नलिखित लिखें:

( )
[ < Player | Crate ] -> [ < Player | < Crate ]

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

कभी-कभी कोड की एक पंक्ति को निष्क्रिय करना आवश्यक होता है। बस इसे भविष्य के लिए सहेजने के लिए एक टिप्पणी में बदल दें। आइए बक्से को आगे बढ़ाने के लिए कोड पर टिप्पणी करें, ताकि खिलाड़ी केवल बक्से ले जा सके:

( )
([ > Player | Crate ] -> [ > Player | > Crate ])
( )
[ < Player | Crate ] -> [ < Player | < Crate ]

यदि यह काम करता है, तो बक्से को खींचने के लिए कोड पर टिप्पणी करें और निम्नलिखित प्रयास करें:

[ < Player | Crate ] -> [ < Player | > Crate ]

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

[ > Player | Crate ] -> [ Player | > Crate ]

बॉक्स चलता है, लेकिन खिलाड़ी जगह पर रहता है। वस्तुओं को कैसे स्थानांतरित किया जाएगा यह देखने के लिए ^ और v (अक्षर v) के साथ प्रयोग करें।

त्रुटियों

आइए जानबूझकर गलत नियम लिखें और देखें कि क्या होता है। निम्नलिखित पंक्ति दर्ज करें:

[ < Player | Crate ] -> [ < Player ]

प्रोग्राम को चलाने का प्रयास करें। आपको इस तरह एक संदेश देखना चाहिए:

पंक्ति 81: एक नियम में, बाईं ओर से मेल खाने वाले प्रत्येक पैटर्न में समान लंबाई (कोशिकाओं की संख्या) के दाईं ओर एक समान पैटर्न होना चाहिए।

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

कुछ और प्रयोग

प्रयोग करने की कोशिश करें और नियम स्वयं लिखें। यहाँ कुछ उदाहरण हैं।

[ > Player | … | Crate ] -> [ > Player | … | > Crate ]

ऊपर दिए गए उदाहरण में, खिलाड़ी बॉक्स को धक्का देगा यदि वे कहीं भी समान स्तर की रेखा पर हों, और खिलाड़ी बॉक्स पर चला जाए।

[ > Player | Crate ] -> [ Crate | Player ]

यह कोड खिलाड़ी और बॉक्स को स्वैप करता है।

[ > Player | Crate ] -> [ Player | Target ]

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

भाग 3. वस्तुओं का निर्माण

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

सामान्य जानकारी

एक नमूना परियोजना खोलें। ऑब्जेक्ट बनाने की प्रक्रिया में निम्नलिखित चरण होते हैं:

• इसे वस्तुओं की सूची में बनाएँ
• किसी किंवदंती में एक आइटम जोड़ना
• एक परत में टकराव जोड़ना

इन सभी चरणों को पूरा करने के बाद, आप ऑब्जेक्ट का उपयोग शुरू कर सकते हैं।

वस्तु निर्माण

कई वस्तुएं पहले से मौजूद हैं। प्रत्येक खेल में एक पृष्ठभूमि वस्तु होनी चाहिए। सभी ऑब्जेक्ट 5 x 5 पिक्सेल ग्रिड से बनाए गए हैं और इनमें कम से कम एक रंग है। पृष्ठभूमि ऑब्जेक्ट नीचे दिखाया गया है।

Background
LIGHTGREEN GREEN
11111
01111
11101
11111
10111

संख्या छवि में पिक्सेल को दर्शाती है। प्रत्येक संख्या अपने रंग से मेल खाती है। पहले रंग की संख्या 0, दूसरी - 1, और इसी तरह 9 तक है। इसमें अधिकतम दस रंग हो सकते हैं। हमारे मामले में, प्रत्येक 1 हल्के हरे (हल्के हरे रंग) में पिक्सेल को रंग देता है, और 0 - हरे (हरे) में। परिणाम इस तरह दिखता है:


ऑब्जेक्ट हमेशा निम्नानुसार बनाए जाते हैं:

• नाम
• रंग
• छवि

नाम हमेशा शीर्ष रेखा पर होता है। रंग हमेशा दूसरी पंक्ति पर होते हैं, और छवि अगली 5 पंक्तियों, प्रति पंक्ति 5 वर्णों को लेती है, जो 5 x 5 ग्रिड बनाती है। या आप निम्न कार्य कर सकते हैं:

Background
LIGHTGREEN

यह कोड "बैकग्राउंड" नामक एक ऑब्जेक्ट बनाएगा, जो हल्के हरे रंग में 5 x 5 पिक्सेल का ग्रिड होगा। यदि आप छवि ग्रिड का वर्णन नहीं करते हैं, तो हमें ठोस रंग का एक ब्लॉक मिलता है, जो कभी-कभी उपयोगी हो सकता है।

वस्तुओं को नाम दें

ऑब्जेक्ट्स को आप जैसे चाहें कह सकते हैं, लेकिन नाम एक प्रतीक से शुरू नहीं हो सकता है और यह रिक्त स्थान के बिना एक शब्द होना चाहिए। वस्तुओं को स्पष्ट नाम दें, लेकिन बहुत दूर न जाएं। PlayerStill एक अच्छा नाम है, PlayerThatIsStandingStill बहुत लंबा और क्रिया है।

रंग

आपको उन रंगों को घोषित करना होगा जिन्हें आप ऑब्जेक्ट के लिए उपयोग करना चाहते हैं और उन्हें एक स्थान के साथ अलग करते हैं। पहेली स्क्रिप्ट में पूर्वनिर्धारित रंग हैं:

• काला
• सफेद
• धूसर
• darkgrey
• lightgrey
• धूसर
• darkgray
• lightgray
• लाल
• darkred
• lightred
• भूरा
• darkbrown
• lightbrown
• नारंगी
• पीला
• ग्रीन
• darkgreen
• lightgreen
• नीला
• lightblue
• darkblue
• बैंगनी
• गुलाबी
• पारदर्शक

आप हेक्साडेसिमल में रंग भी सेट कर सकते हैं, जो हमें रंगों की एक विस्तृत श्रृंखला प्रदान करता है। आप हेक्साडेसिमल रंगों का चयन करने के लिए इस तरह की वेबसाइटों का उपयोग कर सकते हैं। इच्छित रंग का चयन करें, और फिर छवि के ऊपर रंग कोड को फिर से लिखें। हेक्साडेसिमल रंग कोड पहेली लिपि में निम्नानुसार लिखे गए हैं:


#51A2BD #ff0000 #ffffff

रंग कोड हमेशा # वर्ण से पहले होता है।

किंवदंती में एक वस्तु जोड़ें

ऑब्जेक्ट बनाने के बाद, आपको इसे किंवदंती में जोड़ने की आवश्यकता है। किंवदंती इस प्रकार है:

. = Background
# = Wall
P = Player
* = Crate
@ = Crate and Target
O = Target

प्रत्येक प्रतीक एक स्तर में एक वस्तु का प्रतिनिधित्व करता है। अर्थात्, जब हम वर्णों का ऐसा ग्रिड देखते हैं:

#p.*.##
#.**.##
#..#..#
##....#
##...o#
#######

यह वास्तव में हमारे स्तर का वर्णन करता है:


प्रत्येक बनाई गई वस्तु को एक पत्र, प्रतीक या संख्या निर्दिष्ट करनी चाहिए जो इस वस्तु को स्तर पर नामित करती है। इस तरह:

P = player

कथा में समूह की वस्तुएं

हम किंवदंती में वस्तुओं के समूह भी बना सकते हैं। उदाहरण के लिए, यदि हमारे पास कई बहु-रंगीन बॉक्स हैं, तो हम ऐसा कर सकते हैं:

O = OrangeCrate
B = BlueCrate
G = GreenCrate

यह हमें संपादक स्तर में बक्से का उपयोग करने की अनुमति देगा। लेकिन कोड बनाने के लिए, आप उन्हें लेजेंड में एक साथ समूहित कर सकते हैं, जैसे:

Crates = OrangeCrate or GreenCrate or BlueCrate

और सब एक साथ इस तरह दिखेगा:

=======
LEGEND
=======
O = OrangeCrate
B = BlueCrate
G = GreenCrate

Crates = OrangeCrate or GreenCrate or BlueCrate

ऐसा क्यों? क्योंकि तब इस तरह के नियम बनाने के बजाय:

[ > Player | OrangeCrate ] -> [ > Player | > OrangeCrate ]
[ > Player | BlueCrate] -> [ > Player | > BlueCrate ]
[ > Player | GreenCrate] -> [ > Player | > GreenCrate]

आप बस लिख सकते हैं:

[ > Player | Crates ] -> [ > Player | > Crates ]

और यह कोड वस्तुओं के पूरे समूह के लिए काम करेगा।

इसके अलावा, टकराव परतें अनुभाग में, आप उस परत का उल्लेख कर सकते हैं जिसमें समूह स्थित है, बजाय प्रत्येक व्यक्तिगत वस्तु में प्रवेश करने के।

टक्कर की परतें

डिफ़ॉल्ट रूप से, टक्कर परत अनुभाग निम्नानुसार है:

Background
Target
Player, Wall, Crate

प्रत्येक रेखा अपनी परत में वस्तुओं का चयन करती है। वस्तुओं की परतों का क्रम निर्धारित करता है कि कौन सी वस्तुएँ दूसरों के शीर्ष पर होंगी। शीर्ष पंक्ति में ऑब्जेक्ट नीचे की परत पर होंगे, अगली पंक्ति उसके ऊपर की परत में होगी, और इसी तरह। पृष्ठभूमि हमेशा नीचे की परत पर होने के लिए शीर्ष रेखा पर होनी चाहिए। एक परत में वस्तुएँ एक दूसरे के ऊपर नहीं हो सकती हैं। अर्थात्, यह नहीं हो सकता है:

[ player wall ] -> [ player wall ]

आप विभिन्न परतों में वस्तुओं को एक दूसरे के साथ बातचीत कर सकते हैं। उदाहरण के लिए, आप लिख सकते हैं:

[ > Player | Target ] -> [ > Player | > Target ]

एक प्रयोग

कुछ नई वस्तुएं बनाएं। एक प्रकार के बक्से बनाएं जिन्हें आप केवल धक्का दे सकते हैं। एक और बॉक्स बनाएं जिसे केवल खींचा जा सके। एक बॉक्स बनाएं जो आपके छूने पर गायब हो जाए। प्रयोगों को जारी रखते हुए, आप बेहतर याद रखेंगे कि सब कुछ कैसे किया जाता है।

भाग 4. विजय की स्थिति

हर कोई जीतना पसंद करता है। हम, खिलाड़ी के रूप में, जीतना चाहते हैं। इस भाग में, हम सीखेंगे कि गेम जीतने के लिए शर्तों को कैसे प्रोग्राम किया जाए।

विजय की स्थिति

नमूना परियोजना डाउनलोड करें और विन कंडीशंस कोड अनुभाग पर जाएं। आपको निम्नलिखित देखना चाहिए:

All Target on Crate

प्रत्येक गोल पर एक बॉक्स होने पर खेल जीता जाता है। यदि आपके पास 3 बक्से और 2 लक्ष्य हैं, तो आप लक्ष्यों पर केवल 2 बॉक्स सेट करके जीतते हैं। अगर स्वैपिंग होती है:

All crate on target

फिर प्रत्येक बॉक्स को लक्ष्य पर रखना होगा।

एक या कई शर्तें हो सकती हैं। कई स्थितियों के मामले में, वे सभी को संतुष्ट होना चाहिए। उदाहरण के लिए, हमारे पास निम्नलिखित हो सकते हैं:

All Target on Crate
All Target2 on Crate2

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

विभिन्न प्रकार की जीत की स्थिति

कई अलग-अलग प्रकार की जीत की स्थिति है।

No Object

इस मामले में, जीत तब होती है जब स्तर पर ऐसी कोई वस्तु नहीं होती है।

Some Object

आप जीतते हैं जब स्तर पर निर्दिष्ट प्रकार का कम से कम एक ऑब्जेक्ट होता है।

Some Object1 on Object2

Object2 पर कम से कम Object1 में से एक ऑब्जेक्ट होना चाहिए।

No Object1 On Object2

यह स्थिति All Target on Crate के विपरीत है। इस मामले में, हमें इन सभी वस्तुओं को एक दूसरे से अलग होने की आवश्यकता है, न कि एक दूसरे के ऊपर। आप एक-दूसरे के साथ विभिन्न जीत स्थितियों को भी जोड़ सकते हैं।

एक प्रयोग

हम जीत की विभिन्न परिस्थितियों के साथ प्रयोग करेंगे। एक खेल बनाने की कोशिश करें जिसमें जीत होती है अगर सभी बक्से निशाने पर नहीं होते हैं। या एक गेम बनाएं जिसमें आपको एक निश्चित प्रकार के सभी बक्से को नष्ट करने की आवश्यकता होती है, लेकिन आपके रास्ते में अन्य धक्का बॉक्स हैं।

मेरा पूरा किया हुआ उदाहरण प्रोजेक्ट यहाँ देखा जा सकता है ।

भाग 5. देर से कमान

PuzzleScript में एक बहुत ही उपयोगी कमांड है जिसे "देर से" कहा जाता है। खेल में घटनाओं की उत्पत्ति का क्रम महत्वपूर्ण है, और कभी-कभी आपको एक कोड की आवश्यकता होती है जिसे बाद में वांछित परिणाम प्राप्त करने के लिए निष्पादित किया जाता है। इस भाग में मैं देर से आदेश का उपयोग करने के बारे में बात करूंगा।

हमें इसकी आवश्यकता क्यों है

एक उदाहरण परियोजना खोलें, फिर खेल में निम्नलिखित कोड पेस्ट करें और इसे चलाएं:

[ player | target ] -> [ player | ]

यह उम्मीद की जा सकती है कि जैसे ही खिलाड़ी लक्ष्य के बगल में खड़ा होगा, लक्ष्य नष्ट हो जाएगा, लेकिन ऐसा होता नहीं है। इसके बजाय, खिलाड़ी के बगल में खड़ा होने के बाद पाठ्यक्रम में लक्ष्य गायब हो जाता है। इसलिए एक और कोड आज़माएं:

late [ player | target ] -> [ player | ]

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

घटनाओं का क्रम

यहां बताया गया है कि पहेली स्क्रिप्ट में कोड हर मूव के साथ कैसे निष्पादित होता है।

1. पहेली स्क्रिप्ट पता चलता है कि खिलाड़ी को स्थानांतरित करना चाहता है
2. जब भी संभव हो, नियमों को ऊपर से नीचे तक पढ़ा और निष्पादित किया जाता है।
3. यदि संभव हो तो खिलाड़ी चलता है
4. देर से नियम लागू होते हैं

कंप्यूटर कोड की शीर्ष पंक्ति से शुरू होता है और नीचे पढ़ता है, लाइन से लाइन। हर हालत की जाँच। इसलिए जब आप घूमने की कोशिश करते हैं, तो पजल स्क्रिप्ट सभी नियमों और चेकों को पढ़ती है, यह देखने के लिए कि क्या स्थितियां सही हैं और यदि ऐसा है, तो यह कुछ करता है। उदाहरण के लिए, पहली पंक्ति इस तरह हो सकती है:

[ player | spikeTrap ] -> [ | spikeTrap ]

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

व्यवहार में लेट का उपयोग करने के तरीके

मेरे अनुभव में, स्वर्गीय आदेश का उपयोग करना सबसे अच्छा है जब आप यह देखने के लिए जाँच कर रहे हैं कि क्या वस्तुएं एक दूसरे के ऊपर या एक दूसरे के बगल में हैं, लेकिन अन्य मामले हैं। यदि आप जांचते हैं कि क्या एक वस्तु दूसरे पर है, तो घटना अगली बारी तक पंजीकृत नहीं होगी, जब तक कि आप देर से कमांड का उपयोग नहीं करते हैं:

[ player spikeTrap ] -> [ spikeTrap ]

उपरोक्त मामले में, खिलाड़ी जाल में जाने के बाद अगले मोड़ तक दांव के साथ एक जाल से नहीं मारा जाएगा। खिलाड़ी को तुरंत मरने के लिए, बस लेट कमांड जोड़ें,

late [ player spikeTrap ] -> [ spikeTrap ]

संपूर्ण स्तर को पुनरारंभ करने के लिए जब चरित्र मर जाता है, तो आप निम्न कार्य कर सकते हैं:

late [ player spikeTrap ] -> restart

और जब खिलाड़ी दांव में फंस जाता है तो स्तर फिर से शुरू हो जाएगा।

आप तैयार परियोजना का उदाहरण यहां देख सकते हैं।

भाग 6. ध्वनि प्रभाव के साथ काम करें।

हमने पहेली स्क्रिप्ट पर एक शानदार खेल बनाया, लेकिन अब हमें इसमें ध्वनियों को जोड़ने की जरूरत है। यह कैसे करना है? अब मैं आपको बताऊंगा!

ध्वनि पीढ़ी

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


येलो नंबर्स यूनिक कोड होते हैं जिन्हें कोड की उन जगहों पर कॉपी और पेस्ट करना होता है जहां साउंड की जरूरत होती है।

ध्वनियों का उपयोग कैसे करें

एक बार जब आप सही आवाज़ पाते हैं, तो आपको इसे गेम कोड के ध्वनियों अनुभाग में सम्मिलित करना होगा।


ध्वनियों का उपयोग कई तरीकों से किया जा सकता है। सबसे आसान एक नया ध्वनि प्रभाव (sfx) बनाना है। उन्हें क्रमांकित किया जाना चाहिए। हम एक नया sfx बनाते हैं, जो संख्यात्मक ध्वनि आईडी सम्मिलित करते हुए इसे 0 से 10 तक की संख्या प्रदान करता है। ध्वनियों की सूची में, sfx0 नामक एक नया sfx बनाएं और इसे उत्पन्न ध्वनि प्रदान करें:

sfx0 36301705

ध्वनि का उपयोग करने के लिए, आपको इसे घटना के बाद नियमों में सम्मिलित करना होगा। आइए बॉक्स विनाश घटना के लिए नए बनाए गए sfx0 को संलग्न करें (घटना पहले से ही परियोजना उदाहरण में मौजूद है):

(The player destroys a crate)
[ > Player | CrateVanish ] -> [ Player | ] sfx0

उदाहरण के लिए, ध्वनियों को प्लेबैक के लिए भी घोषित किया जा सकता है:

Crate MOVE 36772507

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

CratePull MOVE 12735307

घटनाओं की ध्वनियों को केवल ध्वनि अनुभाग में घोषित किया जाना चाहिए: उन्हें नियमों में उल्लिखित होने की आवश्यकता नहीं है।

ध्वनि प्रजनन विधियों की सूची

नीचे उन विभिन्न ईवेंट ध्वनियों की एक सूची दी गई है, जिनका आप उपयोग कर सकते हैं, जिन्हें स्क्रिप्ट स्क्रिप्ट प्रलेखन से लिया गया है।

ऑब्जेक्ट एक्शन 541566 - एक चाल के दौरान एक वस्तु के संपर्क में आने पर खेलता है।

ऑब्जेक्ट 641667 बनाएं - एक विशिष्ट ऑब्जेक्ट बनाते समय खेलता है।

एंडगेम 5416789 - खेल समाप्त होने पर खेलता है।

EndLevel 6417822 - स्तर के पूरा होने के बाद खेलता है।

ऑब्जेक्ट केंटमोव 781673 - तब बजता है जब कोई वस्तु किसी भी दिशा में स्थानांतरित करने का असफल प्रयास करती है।

प्लेयर कैंटोव डाउन लेफ्ट 464674 - तब खेलता है जब किसी ऑब्जेक्ट को नीचे ले जाने या छोड़ने की असफल कोशिश की जाती है।

CloseMessage 344456 - जब खिलाड़ी मैसेज बॉक्स को बंद करता है, तब खेलता है।

ऑब्जेक्ट नष्ट 187975 - एक वस्तु नष्ट होने पर खेलता है।

ऑब्जेक्ट मूव 264567 - तब बजता है जब कोई ऑब्जेक्ट किसी भी दिशा में सफलतापूर्वक चलता है।

ऑब्जेक्ट लेफ्ट लेफ्ट 765432 - तब चलता है जब ऑब्जेक्ट सफलतापूर्वक नीचे या बाईं ओर चला जाता है।

ऑब्जेक्ट मूव क्षैतिज 345367 - तब निभाता है जब ऑब्जेक्ट सफलतापूर्वक क्षैतिज रूप से स्थानांतरित हो जाता है। आप वर्टिकल का भी इस्तेमाल कर सकते हैं।

पुनरारंभ करें 7865435 - जब कोई खिलाड़ी पुनः आरंभ बटन दबाता है तो खेलता है आर।

SFX0 765743 - SFX0 से SFX10 तक कुछ भी हो सकता है। ये विशेष ध्वनि घटनाएं हैं जिन्हें नियमों से किया जा सकता है।

ShowMessage 478483 - संदेश प्रदर्शित होने पर खेलता है।

StartGame 234626 - एक नए गेम की शुरुआत में खेलता है।

स्टार्टलवेल 765436 - प्रत्येक स्तर की शुरुआत में खेलता है।

टाइटलस्क्रीन 876543 - स्क्रीन सेवर को लोड करने के बाद खेलता है।

436234 पूर्ववत करें - जब कोई खिलाड़ी रद्द कुंजी (Z) दबाता है तो खेलता है।

आप चाल और केंटमव के लिए निर्देश निर्दिष्ट कर सकते हैं ताकि विभिन्न दिशाओं में चलते समय विभिन्न ध्वनियों का पुनरुत्पादन हो।

परियोजना का तैयार उदाहरण यहां दिया गया है ।

भाग 7. संगीत चलायें

हमने पहेली स्क्रिप्ट पर गेम बनाना सीखा, लेकिन क्या उनके लिए संगीत जोड़ना बहुत अच्छा नहीं होगा? यह संभव है, और अब मैं आपको बताऊंगा कि यह कैसे करना है।

नोट: ऐसा लगता है कि इस समय पहेली स्क्रिप्ट में यह फ़ंक्शन टूट गया है, इसलिए अगले भाग पर जाएं।

क्या करें?

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

youtube.com/watch?v= CKAc3nYEatw

वीडियो से संगीत चलाने के लिए, हमें एक विशिष्ट वीडियो आईडी प्राप्त करनी होगी। ऊपर की लाइन में हरा हिस्सा एक यूनिक आईडी है।


परियोजना की शुरुआत में लेखक के होमपेज के तहत, यूट्यूब लेबल जोड़ें, और इसके बाद एक अद्वितीय वीडियो आईडी, उदाहरण के लिए, इस तरह:

youtube CKAc3nYEatw

यह सुनिश्चित करने के लिए कि यह सही ढंग से काम करता है, "शेयर" पर क्लिक करें और गेम लिंक (स्रोत कोड लिंक नहीं) पर क्लिक करें। संपादक के अंदर परीक्षण के दौरान, पहेली स्क्रिप्ट संगीत नहीं चलाया जा सकता है। यदि आप चाहते हैं कि गेम में संगीत हो, तो आपको इसे Youtube पर एक वीडियो के रूप में अपलोड करने और अपने प्रोजेक्ट में एक अद्वितीय आईडी सम्मिलित करने की आवश्यकता है। प्रत्येक प्रोजेक्ट में केवल एक Youtube वीडियो हो सकता है।

परियोजना का उदाहरण

एक उदाहरण पहेली स्क्रिप्ट परियोजना यहाँ पाया जा सकता है ।

भाग 8. एक्शन कमांड का उपयोग कैसे करें

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

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

टीम के साथ काम करना ऊपर वर्णित प्रारूप का अनुसरण करता है। हमने मूल पहेलीस्क्रिप्ट कोड प्रारूप का उपयोग किया है:

[ ] -> [ ]

अगर हालत सही है, तो हम घटना को अंजाम देते हैं। एक्शन कमांड का उपयोग उसी तरह किया जाता है, लेकिन इसके अपने नियम हैं। यह इस तरह दिखता है:

[ Action ] -> [ ]

यहां एक्शन कमांड का उपयोग करने का एक उदाहरण दिया गया है:

[ Action Player ] -> [ Crate ]

पहला, एक्शन हमेशा एक शर्त का पहला शब्द है।

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

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

गेम प्रोजेक्ट में ऊपर दिखाए गए कोड की जाँच करें। आप इस उदाहरण से शुरू कर सकते हैं । आप देखेंगे कि जब आप स्पेस बार या X दबाते हैं , तो खिलाड़ी एक बॉक्स बन जाता है।

स्थिति कहती है [ अगर हम एक्शन कुंजी दबाते हैं और स्तर पर एक प्लेयर ऑब्जेक्ट है ] -> तो [ खिलाड़ी बॉक्स के साथ प्लेयर ऑब्जेक्ट को बदलें ]

अब, प्रोजेक्ट उदाहरण में निम्न कोड का प्रयास करें:

[ Action Player | Crate ] -> [ Player | > Crate ]

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

अद्यतन संस्करण के साथ कोड बदलें:

[ Action Player | Crate ] -> [ Action Player | > Crate ]

अब हम एक ही बार में सभी बक्से को आगे बढ़ा सकते हैं। यदि आपको कई वस्तुओं पर कार्रवाई करने की आवश्यकता है, तो स्थिति और घटना दोनों में कार्रवाई करें ।

भाग 9. कई स्थितियों की जाँच

चलो कई स्थितियों की जांच करना सीखते हैं, उदाहरण के लिए, एक बम और विनाशकारी ब्लॉक की उपस्थिति।


एक नमूना परियोजना खोलें । अब इसमें निम्न कोड जोड़ें:

late [Player Switch][DoorClosed] -> [Player Switch][DoorOpen]

कोड इस प्रारूप का अनुसरण करता है:

[ 1 ] [ 2 ] -> [ 1 ] [ 2 ]

यदि स्थिति 1 सत्य है और स्थिति 2 सत्य है, तो चरण 1 और चरण 2 निष्पादित किए जाते हैं। हमारे मामले में, स्थिति 1 में, यह जांचा जाता है कि क्या खिलाड़ी स्विच पर है। यदि हाँ, तो स्थिति 2 की जाँच की जाती है, अर्थात्, एक बंद दरवाजे के स्तर पर उपस्थिति? यदि स्थिति सही है, तो डोर क्लोज्ड ऑब्जेक्ट डोरऑपेन ऑब्जेक्ट में बदल जाता है, जिससे दरवाजा खुलता है।


मान लीजिए कि नायक को स्विच छोड़ने पर हमें दरवाजे को बंद करने की आवश्यकता होती है, क्योंकि हम चाहते हैं कि खिलाड़ी बॉक्स को खोलने के लिए स्विच पर धक्का दे। आप कुछ इस तरह लिख सकते हैं:

late [Player | Switch][DoorOpen] -> [Player | Switch][DoorClosed]

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

late [Crate Switch][DoorClosed] -> [Crate Switch][DoorOpen]

अब दरवाजा खुला रहेगा जबकि दराज स्विच पर है।

आप तैयार परियोजना का उदाहरण यहां देख सकते हैं ।

भाग 10. ब्रेकपॉइंट बनाना

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

ब्रेकपॉइंट बनाएं

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

late [ Player FlagRed ] -> CHECKPOINT

FlagRed एक चौकी है। जब खिलाड़ी ध्वज के शीर्ष पर होता है, तो यह कोड एक चेकपॉइंट (CHECKPOINT) बनाता है। यदि आप देर से उपयोग नहीं करते हैं, तो चेकपॉइंट फ़ंक्शन काम नहीं करेगा।

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

एकाधिक नियंत्रण अंक

यदि कई नियंत्रण बिंदु हैं, तो खेल खिलाड़ी द्वारा अंतिम सक्रिय का उपयोग करता है।

पहले से उपयोग किए गए नियंत्रण बिंदु पर पुन: सक्रिय होने से बचने के लिए, आपको इसे किसी अन्य ऑब्जेक्ट में बदलने की आवश्यकता है। ऐसा करने के लिए, लाल ध्वज के नीचे कोड के OBJECTS अनुभाग में एक सफेद कॉपी बनाएं।

FlagWhite
White Orange
.1…
.00..
.000.
.1…
.1…

अब पौराणिक कथा में इस पंक्ति को फिर से लिखें:

Flag = FlagRed or FlagWhite

हम वस्तुओं का एक समूह बना सकते हैं। इस मामले में, फ्लैग या तो फ्लैग्ड या फ्लैगवाइट होगा। जब तक कम से कम एक समूहीकृत ऑब्जेक्ट को एक प्रतीक सौंपा जाता है (हमने फ्लैगRed को एक प्रतीक F दिया है), हमें समूह की अन्य वस्तुओं को प्रतीक आवंटित करने की आवश्यकता नहीं होगी, और आप उन्हें केवल कोड में एक्सेस कर सकते हैं, लेकिन स्तर संपादक में नहीं। फिर आप समूह को टकराव की परतें असाइन कर सकते हैं, जो हमने किया था। उदाहरण के लिए, ऑब्जेक्ट्स के समूह तक पहुंच, ध्वज, संपूर्ण समूह को संदर्भित करता है। इसलिए:

[ > Player | Flag ] -> [ > Player | ]

यह कोड लाल और सफेद दोनों झंडे को प्रभावित करेगा।

ध्वज वस्तु बदलें

यहां देखें कि फ्लैगRed को फ्लैग वाइट में कैसे बदला जाए:

late [ Player FlagRed ] -> [ Player FlagWhite ]

यदि मोड़ के अंत में खिलाड़ी लाल झंडे पर होता है, तो हम इसे सफेद रंग में बदल देते हैं। हालाँकि, आपको ब्रेकपॉइंट बनाने के बाद फ्लैग ग्राफिक्स को बदलने की आवश्यकता है , क्योंकि कोड ऊपर से नीचे तक पढ़ा जाता है। कार्यक्रम का परीक्षण करें।

दूसरा ध्वज बदलें

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

late [ Player FlagRed ][ FlagWhite] -> [ Player FlagRed ][FlagBlack]

कोड कहता है: यदि खिलाड़ी लाल झंडे पर है और खेल में कहीं सफेद झंडे हैं, तो आपको सफेद झंडे को काला करने की आवश्यकता है। चूंकि कोड ऊपर से नीचे तक पढ़ा जाता है, हमें निम्न क्रम में ऐसा करने की आवश्यकता है:

late [ Player FlagRed ] -> CHECKPOINT
late [ Player FlagRed ][ FlagWhite] -> [ Player FlagRed ][FlagBlack]
late [ Player FlagRed ] -> [ Player FlagWhite ]

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

[ > Player | Crate ] -> [ > Player | > Crate ]
[ > Crate | Flag ] -> [ Crate | Flag ]
late [ Player FlagRed ] -> CHECKPOINT
late [ Player FlagRed ] -> [ Player FlagWhite ]
late [ Player FlagRed ][ FlagWhite] -> [ Player FlagRed ][FlagBlack]

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

भाग 11. एनिमेशन

PuzzleScript में एनिमेशन बनाने के दो तरीके हैं। उनमें से एक वास्तविक समय का उपयोग करता है, लेकिन इस भाग में मैं इसके बारे में बात नहीं करूंगा। एक अन्य का उपयोग त्वरित एक बार के एनिमेशन के लिए किया जाता है, जैसे कि एक विस्फोट या एक ऊर्ध्वाधर सीढ़ी पर उतरने वाला चरित्र।

एक नमूना परियोजना खोलें । हम एक बम और विस्फोट के शॉट्स की एक श्रृंखला बनाएंगे, और फिर उन्हें चेतन करेंगे।

वस्तु एनीमेशन

2 डी एनिमेशन के लिए, आपको एक राज्य से दूसरे राज्य में जाने वाली वस्तु के कई चित्र चाहिए, उदाहरण के लिए, एक चल रहे मारियो का एक प्रेत। इसमें एनीमेशन के 4 फ्रेम हैं।


एनीमेशन के एक फ्रेम के दूसरे में संक्रमण का अनुकरण करने के लिए, हम पहेलीस्क्रिप्ट में कई ऑब्जेक्ट बनाएंगे जो एनीमेशन के फ्रेम होंगे, और फिर उनके बीच स्विच करने के लिए कोड का उपयोग करें।

बम

ऐसी बम वस्तु बनाओ।

Bomb
black yellow grey
..1..
..1..
.000.
00020
.000.

इसे परतों में और किंवदंती में जोड़ना याद रखें।

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

Explosion1
black yellow grey red
..1..
..1..
.000.
00320
.000.

Explosion2
black yellow grey red
..1..
..1..
.333.
03330
.333.

Explosion3
black yellow grey red
..1..
.333.
33333
33333
.333.

Explosion4
black yellow grey red
.333.
33333
33333
33333
.333.

Explosion5
black yellow grey red
.333.
33333
33.33
33333
.333.

Explosion6
black yellow grey red
.333.
3...3
3...3
3...3
.333.

Explosion7
black yellow grey red
.....
.....
.....
.....
.....

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

[Explosion7] -> []
[Explosion6] -> [Explosion7]
[Explosion5] -> [Explosion6]
[Explosion4] -> [Explosion5]
[Explosion3] -> [Explosion4]
[Explosion2] -> [Explosion3]
[Explosion1] -> [Explosion2]
[Bomb] -> [Explosion1]

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

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

फिर से उपयोग करना

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

[Explosion7] -> []
[Explosion6] -> [Explosion7] again
[Explosion5] -> [Explosion6] again
[Explosion4] -> [Explosion5] again
[Explosion3] -> [Explosion4] again
[Explosion2] -> [Explosion3] again
[Explosion1] -> [Explosion2] again
[Bomb] -> [Explosion1] again

खेल का परीक्षण करें। आप देखेंगे कि पूरा बम एनीमेशन तुरंत खेला जाता है। यदि आपकी राय में यह बहुत धीमा या तेज है, तो गति को बदला जा सकता है। कार्यक्रम पाठ की शुरुआत में, मुखपृष्ठ के नीचे निम्नलिखित कोड लिखें:

again_interval 0.1

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

आप तैयार परियोजना का उदाहरण यहां देख सकते हैं ।

भाग 12. गुरुत्वाकर्षण

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

परियोजना का उदाहरण

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

पतित पावनी १

यहाँ कोड का पहला भाग है जिसका हम उपयोग करेंगे:

down [ Player | no Object ] -> [ | Player ]
down [ Crate | no Object no Player ] -> [ | Crate ]

बॉक्स को किनारे से धकेलने का प्रयास करें। आप देखेंगे कि बॉक्स हिलने के बाद हवा में लटकता है, लेकिन दूसरी चाल के बाद वह जमीन पर गिर जाता है। यहाँ कुछ चीजें होती हैं।

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

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

लेकिन आप यह भी नोटिस कर सकते हैं कि एक चाल के साथ टकराने के बाद, बॉक्स अगले कदम तक नहीं गिरता है, और यह तुरंत जमीन पर पहुंच जाता है। इस विलंबित दुर्घटना को समाप्त करने के लिए, आप देर से खोजशब्द का उपयोग कर सकते हैं:

late down [ Player | no Object ] -> [ | Player ]
late down [ Crate | no Object no Player ] -> [ | Crate ]

लेकिन इसे धीरे-धीरे कैसे गिरना है, फ्रेम से फ्रेम करें?

चरण २ गिरना

अब हम यादृच्छिक कीवर्ड का उपयोग करते हैं । हम निम्नानुसार कोड को फिर से लिखते हैं:

random down [ Player | no Object ] -> [ | Player ]
random down [ Crate | no Object no Player ] -> [ | Crate ]

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

चरण 3 गिरना

अब हम फिर से कीवर्ड जोड़ेंगे :

random down [ Player | no Object ] -> [ | Player ] again
random down [ Crate | no Object no Player ] -> [ | Crate ] again

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

अंतिम चरण

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

[moving Player] -> [moving Player] again
random down [ Player | no Object ] -> [ | Player ] again
random down [ Crate | no Object no Player ] -> [ | Crate ] again

खिलाड़ी के सामने वर्ग कोष्ठक [] में उपयोग किए जाने वाले कीवर्ड का अर्थ है कि हम यह देख रहे हैं कि खिलाड़ी चल रहा है या नहीं। इसका मतलब यह है कि यदि कोई खिलाड़ी चलता है, तो हम उसे आगे बढ़ने और टीम को फिर से चलाने का आदेश देते हैं । फिर तुरंत सब कुछ जो फिर से कीवर्ड का उपयोग करता है काम करेगा ; हमारे मामले में, यह बॉक्स के पतन का एनीमेशन है। आप तैयार परियोजना का उदाहरण यहां देख सकते हैं ।

भाग 13. यात्रा की दिशा की जाँच

दिशा संकेत

कभी-कभी ऐसा होता है कि आपको केवल एक दिशा में कुछ जांचने की आवश्यकता होती है। उदाहरण के लिए, आपको उन ब्लॉकों को बनाने की जरूरत है जो केवल क्षैतिज रूप से धकेल सकते हैं, या एक बतख बना सकते हैं जो केवल बाएं चल सकते हैं।

जैसा कि यह हो सकता है, हम संकेत कर सकते हैं कि घटनाएं केवल कुछ दिशाओं में होती हैं।

PuzzleScript खोलें, बेसिक उदाहरण के आधार पर एक गेम बनाएं और इसे नियमों के साथ निम्नलिखित कोड से बदलें :

[ Left Player ] -> [ Crate ]

गेम लॉन्च करें और देखें कि क्या होता है।

यदि आप बाईं ओर जाने की कोशिश करते हैं, तो खिलाड़ी एक बॉक्स में बदल जाएगा। यह एक अच्छा उदाहरण है कि दिशा कैसे काम करती है।

हम पहले से ही उस प्रारूप के लिए उपयोग किए जाते हैं जिसमें मैंने पहेलीस्क्रिप्ट कोड समझाया था:

[ ] -> [ ]

अगर घटना सत्य है, तो घटना घटती है।

लेकिन अब, जब हमें निर्देशों की जाँच करने की आवश्यकता होगी, तो वह नए नियमों का पालन करेगा:

[ Movement Direction Object Affected ] -> [ New State of Object ]

यह हमारा पिछला कोड है:

[ Left Player ] -> [ Crate ]

जाँच करता है कि खिलाड़ी बाईं ओर ( लेफ्ट ) में जा रहा है या नहीं। यदि ऐसा है, तो हम खिलाड़ी को बॉक्स ऑब्जेक्ट से बदल देते हैं।

गंतव्य के प्रकार

आप निम्न प्रकार के गंतव्यों में से चुन सकते हैं:

• ऊपर
• नीचे
• वाम
• सही
• क्षैतिज (यदि क्षैतिज गति है तो जाँच करता है)
• कार्यक्षेत्र (चेक अगर ऊर्ध्वाधर आंदोलन है)

भाग 14. कस्टम चाल बनाना

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

[ ] -> [ ]

यदि स्थिति सत्य है, तो एक घटना होती है। एक कस्टम चाल बनाने के लिए, आपको निम्नलिखित कार्य करने होंगे:

[ Condition ] -> [ Movement Direction Object To Move ]

यहाँ उदाहरण कैसा दिखेगा:

[ Player | Crate ] -> [ Player | Left Crate ]

पहेलीस्क्रिप्ट डाउनलोड करें , मूल उदाहरण खोलें , इस कोड को पेस्ट करें और देखें कि क्या होता है। उस बॉक्स पर जाएं जिसके चारों ओर दीवारें नहीं हैं।

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

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

पिछले भाग से इस कोड को याद रखें?

[ ] -> [ ]

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

[ ] -> [ ]

स्वीकार्य कस्टम चाल

कस्टम आंदोलनों को इनमें से किसी भी शब्द के साथ बनाया जा सकता है:

• ऊपर
• नीचे
• वाम
• सही

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

भाग 15. वस्तुओं के बगल में कोशिकाओं की जाँच करना

कभी-कभी यह जांचना आवश्यक है कि वस्तु के आगे क्या है। यह करना बहुत आसान है। आइए PuzzleScript कोड प्रारूप पर एक और नज़र डालते हैं:

[ ] -> [ ]

वह है

[ ] -> [ ]

ऑब्जेक्ट के किनारे पर जांच करने के लिए, हमें एक तत्व जोड़ना होगा। प्रारूप इस प्रकार है:

[ object1 | object2 ] -> [ object1 | object2 ]

शर्त से पहले, हम जाँच करते हैं कि हम किस ऑब्जेक्ट में चेक करना चाहते हैं।

हालत के अंदर, हम मानते हैं कि कम से कम दो कोशिकाओं की जरूरत है। एक सेल, वास्तव में, कोई भी वस्तु है जो एक ही स्थान पर है और एक दूसरे के बगल में नहीं है।

[ ]

[ | | ]

पहली कोशिका वह वस्तु है जिसकी भुजाएँ हम जाँच रहे हैं। दूसरी कोशिका वह वस्तु है जिसकी उपस्थिति हम जाँच रहे हैं। निम्नलिखित उदाहरण आज़माएँ:

Left [ Player | Crate ] -> [ Player | ]

ऊपर दिखाए गए कोड बॉक्स को हटा देते हैं यदि वे खिलाड़ी के बाईं ओर वर्ग में हैं।

Left [ Crate | Crate ] -> [ Player | Crate ]

यह कोड यह जांचता है कि क्या बॉक्स दूसरे बॉक्स के बाईं ओर है। यदि ऐसा है, तो जिस बॉक्स का साइड चेक किया गया है, वह खिलाड़ी का नया ऑब्जेक्ट बन जाएगा।

Left [ Crate | Crate ] -> [ Crate | Player ]

उपरोक्त कोड में समान चेक है, लेकिन बाईं ओर स्थित बॉक्स खिलाड़ी की वस्तु बन जाता है।

Left [ Crate | Crate | Crate ] -> [ Crate | Player | Crate ]

यह कोड भी इसी तरह के पैटर्न का उपयोग करता है। चेक किए गए बाईं ओर का बॉक्स एक खिलाड़ी बन जाता है अगर 3 बॉक्स एक दूसरे के क्षैतिज रूप से बगल में हों।

Left [ Crate | Crate | Crate ] -> [ Crate | Crate | Player ]

यदि 3 बॉक्स क्षैतिज रूप से एक दूसरे के बगल में हैं, तो सबसे बाईं ओर एक खिलाड़ी बन जाता है।

यदि आप इनमें से प्रत्येक उदाहरण का परीक्षण करते हैं, तो आप पैटर्न को समझना शुरू कर देंगे। पहला सेल वह ऑब्जेक्ट है जिसे हम यह देखने के लिए जांचते हैं कि आगे क्या है। निम्नलिखित कोशिकाएं, निकटतम से लेकर सबसे दूर तक, वे वस्तुएं हैं जिनकी हम जांच करते हैं।

कीवर्ड

• ऊपर - एक वस्तु पर जाँच
• नीचे - वस्तु के नीचे की जाँच
• वाम - वस्तु के बाईं ओर जांच
• अधिकार - वस्तु के अधिकार की जाँच करता है
• क्षैतिज - वस्तु के बाएँ और दाएँ की जाँच करता है
• कार्यक्षेत्र - वस्तु के ऊपर और नीचे की जाँच