फ्लैश और एक्शनस्क्रिप्ट के साथ एक मैच -3 गेम बनाएं

सभी सहयोगियों को नमस्कार।
मैं एक शुरुआती FlashGame डेवलपर हूं। मुझे मैच-तीन गेम बनाने का सबक पसंद आया। मैंने पहली बार पाठ को समझा, लेकिन मैंने अनुवाद क्यों किया? सबसे पहले, मुझे आशा है कि यह किसी ऐसे व्यक्ति की मदद करता है जो अंग्रेजी में अच्छा नहीं है। दूसरे, अनुवाद ने मुझे सभी कोड पूरी तरह से पार्स करने की अनुमति दी, बहुत सावधानी से। अच्छी तरह से और तीसरे, इस यांत्रिकी से शुरू करके आप अपने सपनों के मच -3 का निर्माण शुरू कर सकते हैं। और यह फ़्लैश पर होना जरूरी नहीं है।

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





फ़ील्ड (बोर्ड) = गेम बोर्ड जहां चिप्स स्थित हैं, दृश्य प्रदर्शन
चिप (टुकड़ा) = तत्व जो हम दूसरों के साथ जोड़ते हैं।
पंक्ति (मैच) = पंक्ति या स्तंभ, एक ही प्रकार के कम से कम 3 चिप्स का एक क्रम।
ग्रिड = 2-आयामी मैट्रिक्स जो डिजिटल रूप से एक बोर्ड की नकल करता है।

खेल की कार्यक्षमता अवलोकन।
खेल में सभी घटनाओं के अनुक्रम में 12 चरण शामिल हैं, जहां प्रत्येक चरण एक अलग कार्य है।
1. बेतरतीब ढंग से उत्पन्न खेल मैदान का निर्माण।
बेतरतीब ढंग से रखे गए चिप्स के साथ 8x8 फ़ील्ड बनाना, जिनमें से प्रत्येक में 7 अलग-अलग डिस्प्ले विकल्प हो सकते हैं।
2. लाइन पर जाँच करें।
मैदान पर चिप्स की प्रारंभिक व्यवस्था पर कुछ प्रतिबंध हैं। सबसे पहले, खेल की शुरुआत में फ़ील्ड में लाइनें नहीं होनी चाहिए।
3. पहली चाल की संभावना के लिए जाँच करें।
दूसरी सीमा खिलाड़ी को कम से कम एक चाल चलने की अनुमति देना है। अर्थात्, फ़ील्ड में प्रारंभ में असम्बद्ध रचना नहीं होनी चाहिए।
4. खिलाड़ी 2 चिप्स का चयन करता है।
चिप्स एक दूसरे के बगल में (लंबवत या क्षैतिज रूप से) होने चाहिए और एक लाइन बनाने के लिए इनका आदान-प्रदान होता है।
5. चिप्स की अदला-बदली होती है।
यहां हम सबसे सरल एनीमेशन का उपयोग करते हैं।
6. लाइन पर जाँच करें।
विनिमय के बाद, हम मैदान पर लाइनों की तलाश करते हैं। यदि कोई रेखाएं नहीं मिलती हैं, तो चिप्स को वापस जगह पर स्वैप करें।
7.जब लाइन मिल जाए, तो हम खिलाड़ी को अंकों के साथ पुरस्कृत करते हैं।
8. हम फ़ील्ड से लाइनें निकालते हैं।
9. गायब हुए स्थान पर ऊपरी टुकड़ों को स्थानांतरित करें।
10. परिणामी voids को भरें।
11. फिर हम लाइन पर जांच करते हैं। हम पैराग्राफ 6 पर लौटते हैं।
सभी चिप्स खाली सीटों पर गिर गए, और नए लोगों ने voids को भर दिया, आपको लाइन पर फिर से जांच करने की आवश्यकता है।
12. प्रगति की संभावना के लिए जाँच करें।
इससे पहले कि आप खिलाड़ी को एक चाल में पास करें, आपको यह सुनिश्चित करने की ज़रूरत है कि मैदान पर संभावित चालें हैं।

हमारी क्लिप और क्लास माचिस
MatchThree.fla क्लिप बहुत सरल है। लाइब्रेरी में एरियल फॉन्ट के अलावा, हमारे यहाँ सात फ्रेम की एक क्लिप है। कलर लेयर में, प्रत्येक फ्रेम में एक अलग प्रकार की चिप होती है। शीर्ष चयन परत का उपयोग चयनित चिप को फ़्रेम (चयन) करने के लिए किया जाता है और बाद में दृश्यमान संपत्ति द्वारा सक्रिय किया जाएगा।



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

पैकेज {
आयात फ़्लैश। प्रदर्शित करें । * ;
आयात फ़्लैश। घटनाओं । * ;
आयात फ़्लैश। पाठ । * ;
आयात फ़्लैश। बर्तन । टाइमर;

हमारे पास निम्नलिखित स्थिरांक हैं: एक स्क्रीन पर स्थिति को उन्मुख करने के लिए चिप के प्रकार (सात अलग-अलग विकल्प) और तीन स्थिरांक को दर्शाता है।

पब्लिक क्लास मैचथ्री का विस्तार
// स्थिरांक
// चिप प्रकार की संख्या
स्टैटिक कास्ट न्यूमप्स: यूइंट = 7 ;
// दो चिप्स के बीच की दूरी
स्थिर गति रिक्ति: संख्या = 45 ;
// छोड़ दिया इंडेंट
स्थिर कास्ट ऑफसेट: संख्या = 120 ;
// ऊपर इंडेंट
स्थिर कास्ट ऑफसेट: संख्या = 30 ;

गेम सेटिंग्स को 5 अलग-अलग वेरिएबल्स में स्टोर किया जाएगा। सबसे पहले, ग्रिड में सभी टुकड़ों के लिंक होंगे। ग्रिड एक द्वि-आयामी सरणी है। प्रत्येक ग्रिड तत्व में 8 टुकड़ों ( मोहरे ) की एक सरणी होगी। यह सब एक मैट्रिक्स, एक 8x8 सरणी की तरह दिखेगा और हम किसी भी चिप को लिंक ग्रिड [x] [y] के माध्यम से एक्सेस कर सकते हैं।
GameSprite स्प्राइट में हमारे द्वारा बनाए गए सभी स्प्राइट और मूवी क्लिप शामिल होंगे। इसलिए हम उन्हें मंच पर पहले से मौजूद किसी भी अन्य ग्राफिक्स से अलग कर देंगे।
चर फर्स्टपाइपर में पहले क्लिक की गई चिप का लिंक होगा।
दो लॉजिकल ( बूलियन ) वैरिएबल आईड्रॉपिंग , आईसपैपिंग ट्रैक करेगा कि हमें फिलहाल किन चिप्स की आवश्यकता है। गेमकोर चर खिलाड़ी अंक को संग्रहीत करेगा।

// खेल ग्रिड और आवश्यक सेटिंग्स
निजी संस्करण ग्रिड: ऐरे ;
निजी var gameSprite: स्प्राइट;
निजी var फर्स्टपॉइंट: टुकड़ा;
निजी varDropping, isSwapping: बूलियन ;
निजी var gameScore: int ;

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

नोट।
आरंभीकरण के लिए खाली स्लॉट के साथ सभी सरणी तत्वों को भरने की आवश्यकता नहीं है। सरणी के किसी भी तत्व के लिए मान सेट करते समय, पिछले सभी तत्व अपरिभाषित मान से भरे होते हैं। उदाहरण के लिए, नए बनाए गए एरे में, हम "माई स्ट्रिंग" को तीसरे तत्व (इंडेक्स [2] के तहत) में असाइन करते हैं। सरणी की लंबाई 3 होगी, और तत्वों [0] और [1] को अपरिभाषित मान मिलेगा।

अगला हम वैरिएबल को परिभाषित कर रहा है, अलग कर रहा है , isSwapping और gameScore । हम खेल में चिप्स के सभी आंदोलनों को शुरू करने के लिए ईवेंट ENTER_FRAME पर श्रोता को भी सेट करते हैं।

// ग्रिड को आरंभ करें () और खेल शुरू करें
सार्वजनिक समारोह startMatchThree ( ) {
// ग्रिड (ग्रिड) बनाना और शुरू करना
ग्रिड = नया ऐरे ( ) ;
( var ग्रिड्रो: int = 0 ; ग्रिड्स < 8 ; ग्रिड्रो ++ ) {
ग्रिड। धक्का ( नया ऐरे ( ) ) ;
}
setUpGrid ( ) ;
isDropping = false ;
isSwapping = false ;
gameScore = 0 ;
addEventListener ( घटना। ENTER_FRAME , MovePothers ) ;
}

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

सार्वजनिक समारोह setUpGrid ( ) {
// लूप जब तक हम एक खेलने योग्य ग्रिड नहीं बनाते हैं
जबकि ( सच्चा ) {
// एक प्रेत बनाएँ
gameSprite = नया स्प्राइट ( ) ;

// 64 यादृच्छिक चिप्स जोड़ें
( var col: int = 0 ; col < 8 ; col ++ ) के लिए {
( var पंक्ति: int = 0 ; पंक्ति < 8 ; पंक्ति ++ ) {
addPhew ( कॉल, पंक्ति ) ;
}
}

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

// यदि फ़ील्ड पर लाइनें हैं, तो फिर से प्रयास करें
अगर ( देखोफॉरमैच ( ) । लंबाई ! = 0 ) जारी है ;

// मैदान पर कोई चाल नहीं है तो फिर से कोशिश करें
अगर ( देखोFossPossibles ( ) == गलत ) जारी है ;

// कोई रेखाएं नहीं हैं, और एक चाल है, लूप को तोड़ दें
तोड़ना ;
}
// स्प्राइट जोड़ें
addChild ( gameSprite ) ;
}

चिप्स जोड़ना
AddPhew फ़ंक्शन एक विशिष्ट कॉलम और कॉलम में एक यादृच्छिक चिप बनाता है, और इसे स्क्रीन पर एक स्थान प्रदान करता है।

// एक यादृच्छिक चिप बनाएं, इसे स्प्राइट और ग्रिड में जोड़ें
सार्वजनिक समारोह addPhew ( कॉल, पंक्ति: int ) : टुकड़ा {
var newPiece: टुकड़ा = नया टुकड़ा ( ) ;
newPiece। x = col * रिक्ति + ऑफसेटएक्स;
newPiece। y = पंक्ति * रिक्ति + ऑफसेट;

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

newPiece। col = col;
newPiece। पंक्ति = पंक्ति;
newPiece। प्रकार = गणित । सेल ( गणित । यादृच्छिक ) ( * 7 ) ;
newPiece। gotoAndStop ( newPibl; type ) ;

टुकड़ा क्लिप के अंदर मूवी क्लिप का चयन करें एक फ्रेम है जो एक क्लिक की गई चिप के ऊपर घूमता है। प्रारंभ में, इसकी दृश्यमान संपत्ति झूठी होगी। हम गेम चिप में टुकड़ा चिप क्लिप जोड़ते हैं। ग्रिड में एक चिप जोड़ने के लिए, डबल ब्रैकेट ग्रिड का उपयोग करें [col] [पंक्ति] = newPhew । प्रत्येक चिप के लिए हम एक श्रोता ( श्रोता पर क्लिक करें ) को लटकाएंगे । फिर हम चिप ( टुकड़ा ) के लिंक को वापस कर देंगे। हम इस लिंक को setUpGrid फ़ंक्शन में उपयोग नहीं करेंगे, लेकिन बाद में इसका उपयोग voids को बदलने के लिए नए चिप्स बनाते समय करेंगे।

newPiece। चयन करें । दृश्यमान = झूठा ;
gameSprite। addChild ( newPhew ) ;
ग्रिड [ कर्नल ] [ पंक्ति ] = नया भतीजी;
newPiece। addEventListener ( माउसइवेंट। क्लिक करें , क्लिक करें ) ;
NewPhew वापस करें;
}

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

// खिलाड़ी चिप पर क्लिक करता है
सार्वजनिक समारोह पर क्लिक करें ( इवेंट: माउसइवेंट ) {
var टुकड़ा: टुकड़ा = टुकड़ा ( घटना। वर्तमान गैजेट ) ;

// पहला चिप चयनित
अगर ( फर्स्टपाइ == नल ) {
टुकड़ा। चयन करें । दृश्यमान = सत्य ;
FirstPhew = टुकड़ा;

// पहली चिप पर फिर से क्लिक करें
} और अगर ( FirstPhew == टुकड़ा ) {
टुकड़ा। चयन करें । दृश्यमान = झूठा ;
FirstPibl = null ;

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

// दूसरी चिप पर क्लिक करें
} {
firstPiece। चयन करें । दृश्यमान = झूठा ;

// एक ही पंक्ति, कॉलम में पड़ोस की जाँच करें
अगर ( ( फर्स्टपाइप। पंक्ति == टुकड़ा। पंक्ति ) और& ( गणित । एब्स ( फर्स्टपाइग। कॉलपीस। कॉल ) == 1 ) ) {
makeSwap ( फर्स्टपाइपर, पीस ) ;
FirstPibl = null ;

// एक ही कॉलम, पंक्ति में पड़ोस की जाँच करें
} और यदि ( ( फर्स्टपाइगर। col == टुकड़ा। कर्नल ) && ( गणित । abs ( फ़र्स्टप्यूप। पंक्ति- टुकड़ा। पंक्ति ) == 1 ) ) {।
makeSwap ( फर्स्टपाइपर, पीस ) ;
FirstPibl = null ;

// कोई पड़ोस नहीं है, पहली चिप से पसंद को फेंक दें
} {
FirstPhew = टुकड़ा;
firstPiece। चयन करें । दृश्यमान = सत्य ;
}
}
}

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

// दो चिप्स के आदान-प्रदान का एनीमेशन शुरू करें
सार्वजनिक समारोह मेकवे ( टुकड़ा 1, टुकड़ा 2: टुकड़ा ) {
स्वैपपाइन्स ( टुकड़ा 1, टुकड़ा 2 ) ;

// जाँच करें कि क्या एक्सचेंज सफल रहा
अगर ( देखेंफॉरमैच ( ) । लंबाई == 0 ) {
स्वैपपाइन्स ( टुकड़ा 1, टुकड़ा 2 ) ;
} {
isSwapping = true ;
}
}

एक विनिमय करने के लिए, हमें पहले चिप के स्थान को अस्थायी भंडारण में सहेजना होगा। अगला, पहले चिप को दूसरे स्थान पर ले जाएं, और दूसरे को पहले से पहले से सहेजे गए निर्देशांक तक ले जाएं।



एक्सचेंज के बाद, हमें ग्रिड में मूल्यों को अपडेट करना चाहिए।

// दो चिप्स का आदान-प्रदान
सार्वजनिक समारोह स्वैपपाइप ( टुकड़ा 1, टुकड़ा 2: टुकड़ा ) {
// पंक्ति और कॉल के मूल्यों का आदान-प्रदान करें
var tempCol: uint = piece1 कर्नल ;
var tempRow: uint = piece1 पंक्ति ;
piece1। col = piece2 कर्नल ;
piece1। पंक्ति = टुकड़ा २। पंक्ति ;
piece2। col = tempCol;
piece2। पंक्ति = अस्थायी;

// ग्रिड में स्थिति बदलें
ग्रिड [ टुकड़ा १। कर्नल ] [ टुकड़ा १। पंक्ति ] = टुकड़ा 1;
ग्रिड [ टुकड़ा २। कर्नल ] [ टुकड़ा २। पंक्ति ] = टुकड़ा 2;
}

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

चिप आंदोलन एनीमेशन
हम एक दिलचस्प लेकिन स्पष्ट एनीमेशन विधि का उपयोग नहीं करते हैं। हम प्रत्येक चिप के बारे में जानते हैं जो पंक्ति और स्तंभ में है, पंक्ति और कर्नल के गतिशील गुणों के लिए धन्यवाद। और हम एक्स और वाई के गुणों के आधार पर स्क्रीन पर इसके स्थान का भी पता लगा सकते हैं। चलो स्थिरांक, ऑफसेट , ऑफसेट Y के बारे में मत भूलना। उदाहरण के लिए, कॉलम 3 में चिप का मान x = 3 * रिक्ति + ऑफसेट प्राप्त होगा। अगर चिप दूसरे कॉलम में चली जाए तो क्या होगा? यदि हम चिप को 4 का कोल मान देते हैं, तो x = 4 * रिक्ति + ऑफसेट , जो दाईं ओर 45 पिक्सेल है। इसलिए, चिप को दाईं ओर ले जाएं, अपने गंतव्य के करीब। यदि आप हर फ्रेम को ऐसा करते हैं, तो जल्द ही चिप अपने नए गंतव्य पर पहुंच जाएगी और चलना बंद कर देगी (क्योंकि इसके कॉल और एक्स मान एक दूसरे के अनुरूप होंगे)।
इस तकनीक का उपयोग करके, आप किसी भी चिप को एक नए स्थान पर ले जाने की प्रक्रिया में चेतन कर सकते हैं। हमें मूवी क्लिप स्तर पर एनीमेशन को समायोजित करने की आवश्यकता नहीं है। हमें बस इतना करना है कि टुकड़ा की कॉल या पंक्ति संपत्ति को बदल दें। मूवमेंट फंक्शन पहले से ही बाकी का ध्यान रखते हैं।
मूवमेंट फ़ंक्शन को हर फ्रेम कहा जाता है, क्योंकि हमने इसे श्रोता का उपयोग करके कक्षा की शुरुआत में स्थापित किया था। यह x और y के साथ कॉल और पंक्ति मान के लिए सभी चिप्स की जांच करता है।

नोट।
मूवपॉइंट फंक्शन में , हम प्रत्येक फ्रेम में स्टेप 5 का उपयोग करते हैं। यह मान हमेशा रिक्ति मूल्य का एक से अधिक होना चाहिए। यदि रिक्ति समान थी, उदाहरण के लिए, 48 तक, हम 4, 6 या 8 का उपयोग करेंगे।

// अगर कुछ चिप जगह से बाहर है, तो इसे थोड़ा करीब ले जाएं
// यह एक्सचेंज या चिप गिरने की स्थिति में होता है
सार्वजनिक समारोह मूवमेंट्स ( इवेंट: इवेंट ) {
var मेडमोव: बूलियन = गलत ;
( var पंक्ति: int = 0 ; पंक्ति < 8 ; पंक्ति ++ ) {
( var col: int = 0 ; col < 8 ; col ++ ) के लिए {
अगर ( ग्रिड [ कर्नल ] [ पंक्ति ] ! = अशक्त ) {

// शिफ्ट करें
अगर ( ग्रिड [ कर्नल ] [ पंक्ति ] । वाई < ग्रिड [ कॉल ] [ पंक्ति ] । पंक्ति * रिक्ति + ऑफसेट ) {
ग्रिड [ कॉल ] [ पंक्ति ] । y + = 5 ;
मेडम = सच्चा ;

// शिफ्ट करें
} और यदि ( ग्रिड [ कर्नल ] [ पंक्ति ] । y > ग्रिड [ कॉल ] [ पंक्ति ] । पंक्ति * रिक्ति + ऑफसेट ) {
ग्रिड [ कॉल ] [ पंक्ति ] । y = 5 है ;
मेडम = सच्चा ;
// दाईं ओर शिफ्ट

} और यदि ( ग्रिड [ कर्नल ] [ पंक्ति ] । x < ग्रिड [ कॉल ] [ पंक्ति ] । कोल * रिक्ति + ऑफसेट ) {
ग्रिड [ कॉल ] [ पंक्ति ] । x + = 5 ;
मेडम = सच्चा ;

// शिफ्ट छोड़ दिया
} और अगर ( ग्रिड [ कर्नल ] [ पंक्ति ] । x > ग्रिड [ कर्नल ] [ पंक्ति ] कर्नल * रिक्ति + ऑफसेट ) {
ग्रिड [ कॉल ] [ पंक्ति ] । x = 5 है ;
मेडम = सच्चा ;
}
}
}
}

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

// सभी क्रैश पूर्ण हुए
अगर ( isDropping && ! मेडमोव ) {
isDropping = false ;
findAndRemoveMatches ( ) ;

// सभी एक्सचेंज पूरे हो गए हैं
} और अगर ( isSwapping && ! मेडमोव ) {
isSwapping = false ;
findAndRemoveMatches ( ) ;
}
}

रेखा खोज
हमारे कार्यक्रम के दो जटिल कार्य हैं। और पहला है लाइनों की खोज। उन्हें खोजने का कार्य बल्कि जटिल है और एक सरल विधि द्वारा हल नहीं किया जाता है।

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

टिप्पणी
अंकों की संख्या लाइन में चिप्स की संख्या पर निर्भर करती है। तीन चिप्स का मतलब है (3-1) * प्रत्येक चिप के लिए 50 या 100 अंक। चार चिप्स, (4-1) * 50 या 150 अंक प्रति चिप, कम से कम 600 अंक।

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

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

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

सार्वजनिक समारोह findAndRemoveMatches ( ) {
// लाइनों की एक सूची बनाएँ
var मैच: Array = lookForMatches ( ) ;
के लिए ( var i: int = 0 ; I < माचिस। लंबाई ; i ++ ) {
var अंक: संख्या = ( मिलान [ i ] । लंबाई - 1 ) * 50 ;
के लिए ( var j: int = 0 ; j < मैचों [ i ] । लंबाई ; j ++ ) {
अगर ( gameSprite। होता है । ( मैच [ i ] [ j ] ) ) {
var pb = new PointBurst ( यह , numPoints, मैचों [ i ] [ j ] x ; माचिस [ i ] [ j ] y ) ;
addScore ( numPoints ) ;
gameSprite। removeChild ( मैच [ i ] [ j ] ) ;
ग्रिड [ मैचों [ i ] [ जे ] । col ] [ मैचों [ i ] [ j ] । पंक्ति ] = अशक्त ;
प्रभावितअबोव ( मैच [ i ] [ जे ] ) ;
}
}
}

FindAndRemoveMatches फ़ंक्शन दो कार्य करता है। सबसे पहले, addNewPothers कॉलम में गुम चिप्स को भरता है। तब हम यह सुनिश्चित करने के लिए लुकफोरपॉलीबल्स को बुलाते हैं कि खिलाड़ी अभी भी मैदान पर है। इसकी जरूरत तभी पड़ती है जब नई लाइनें नहीं मिलती हैं। ऐसा तब होता है जब नए चिप्स गिरने के बाद findAndRemoveMatches को कॉल किया गया था और कोई रेखाएं नहीं मिली थीं।

// फ़ील्ड के शीर्ष पर एक नई चिप जोड़ें
addNewPothers ( ) ;

// कोई रेखा नहीं मिली, एक चाल की संभावना के लिए जाँच करें
अगर ( मैच। लंबाई == 0 ) {
अगर (देखो ! )
एंडगेम ( ) ;
}
}
}

LookForMatches फ़ंक्शन
फ़ंक्शन का उद्देश्य पाई गई एक सरणी बनाना है। हम 2 से अधिक चिप्स की लाइनें निर्धारित करते हैं। ऐसा करने के लिए, लूप में एक लूप करें, पहले पंक्तियों में, फिर कॉलम में। प्रत्येक पंक्ति में पहले 6 चिप्स के सेगमेंट की जाँच करें। 7 और 8 से, चेकिंग का कोई मतलब नहीं है, क्योंकि वे 2 से अधिक चिप्स की लाइनें नहीं बना पाएंगे।
GetMatchHoriz और getMatchVert फ़ंक्शन उनके पास किए गए तत्व की शुरुआत से लाइन की लंबाई निर्धारित करते हैं। उदाहरण के लिए, यदि तत्व [3] [६] टाइप ४ की चिप है, [४] [६] भी टाइप ४ की चिप है, और [५] [६] टाइप १ की चिप है, तो गेटमैचोरीज़ (३,६) कॉल २ पाएगी , क्योंकि लाइन मिल गई है 2 चिप्स की।
यदि रेखा पाई जाती है, तो यह प्रभावी रूप से कुछ छोरों को छोड़ देगी और कुछ कदम आगे बढ़ाएगी। उदाहरण के लिए, हमारे पास [2] [1] , [2] [2] , [2] [3] और [2] [4] में एक पंक्ति है, हम सिर्फ [2] [1] की जांच करते हैं , परिणाम 4 लौटाते हैं। [२] [२] , [२] [३] , [२] [४] को छोड़ कर [२] [५] से शुरू करें ।
GetMatchHorizon या getMatchVert का उपयोग करके पाई गई प्रत्येक पंक्ति के लिए , वे पंक्ति में प्रत्येक टोकन युक्त एक सरणी लौटाते हैं। हम लुकफॉरमैच फ़ंक्शन में मिलान सरणी में इन पाए गए सरणियों को जोड़ते हैं।

// सभी पाया लाइनों की एक सरणी लौटें
सार्वजनिक समारोह देखोफ्रेम ( ) : ऐरे {
var matchList: Array = new Array ( ) ;

// क्षैतिज रेखाओं की खोज करें
( var पंक्ति: int = 0 ; पंक्ति < 8 ; पंक्ति ++ ) {
( var col: int = 0 ; col < 6 ; col ++ ) के लिए {
var मैच: Array = getMatchHoriz ( col, row ) ;
अगर ( मैच। लंबाई > 2 ) {
matchList। धक्का ( मैच ) ;
कोल + = मैच। लंबाई - 1 ;
}
}
}

// ऊर्ध्वाधर लाइनों के लिए खोज
for ( col = 0 ; col < 8 ; col ++ ) {
के लिए ( पंक्ति = 0 ; पंक्ति < 6 ; पंक्ति ++ ) {
मैच = getMatchVert ( कॉल, पंक्ति ) ;
अगर ( मैच। लंबाई > 2 ) {
matchList। धक्का ( मैच ) ;
पंक्ति + = मैच। लंबाई - 1 ;
}

}
}
माचिस की तीली;
}

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

//
public function getMatchHoriz ( col,row ) : Array {
var match: Array = new Array ( grid [ col ] [ row ] ) ;
for ( var i: int = 1 ;col+i < 8 ;i++ ) {
if ( grid [ col ] [ row ] . टाइप == ग्रिड [ कॉल + आई ] [ पंक्ति ] । प्रकार ) {
मैच। धक्का ( ग्रिड [ कॉल + आई ] [ पंक्ति ] ) ;
} {
मैच वापसी ;
}
}
मैच वापसी ;
}

समारोह getMatchVert लगभग समान getMatchHorizon , सिवाय इसके कि खोज पंक्तियों और स्तंभों की नहीं है।

//
public function getMatchVert ( bol,row ) : Array {
var match: Array = new Array ( grid [ col ] [ row ] ) ;
for ( var i: int = 1 ;row+i < 8 ;i++ ) {
if ( grid [ col ] [ row ] . type == grid [ col ] [ row+i ] . type ) {
match. push ( grid [ col ] [ row+i ] ) ;
} {
return match;
}
}
return match;
}

समारोह affectAbove
पर विचार करें affectAbove । हम इसमें एक चिप पास करते हैं, और यह उम्मीद करते हैं कि इसके ऊपर के सभी चिप्स बताएं कि यह एक कदम नीचे जा सकता है। लूप में, हम वर्तमान के ऊपर कॉलम में चिप्स को देखते हैं। उदाहरण के लिए, यदि वर्तमान [5] [6] , तो [5] [5] , [5] [4] , [5] [3] , [5] [2] , [5] [1] , [ ५] [०] उस क्रम में। इन चिप्स का पंक्ति मूल्य 1 से बढ़ जाता है। इसके अलावा, वे अपने स्थान के बारे में नए डेटा ग्रिड में संचारित करते हैं। याद रखें कि मूवमेंट फ़ंक्शन के साथ हमें एनीमेशन के बारे में चिंता करने की ज़रूरत नहीं है। हम सिर्फ चिप को एक नया स्थान बताते हैं।

//
public function affectAbove ( piece:Piece ) {
for ( var row: int =piece. row - 1 ;row > = 0 ;row-- ) {
if ( grid [ piece. col ] [ row ] ! = null ) {
grid [ piece. col ] [ row ] . row ++;
grid [ piece. col ] [ row+ 1 ] = grid [ piece. col ] [ row ] ;
grid [ piece. col ] [ row ] = null ;
}
}
}

AddNewPhew फ़ंक्शन
अगले फ़ंक्शन को हमें लिखने की आवश्यकता है, AddNewPothers । यह ग्रिड में सभी अशक्त कोशिकाओं की जाँच करता है और उन्हें नए चिप्स से भरता है। हालाँकि, कॉल और पंक्ति मानों को उनका अंतिम मूल्य मिलता है, वाई को स्क्रीन के शीर्ष पर मान मिलता है, इसलिए चिप्स नीचे गिर जाते हैं। चर .Dropping सच को स्वीकार करता है , जो गिरने वाली चिप के एनीमेशन को इंगित करता है ।

// , , .
public function addNewPieces ( ) {
for ( var col: int = 0 ;col < 8 ;col++ ) {
var missingPieces: int = 0 ;
for ( var row: int = 7 ;row > = 0 ;row-- ) {
if ( grid [ col ] [ row ] == null ) {
var newPiece:Piece = addPiece ( col,row ) ;
newPiece. y = offsetY-spacing-spacing * missingPieces++;
isDropping = true ;
}
}
}
}

संभावित चालें
खोजना संभव रेखाओं को खोजना लाइनों को खोजने की तुलना में बहुत आसान नहीं है।
सबसे आसान तरीका बोर्ड पर पुनरावृति करना है, प्रत्येक चिप के लिए एक विनिमय बनाना है। [0] [0] को [1] [0] , तो [1] [0] को [2] [0] , आदि प्रत्येक एक्सचेंज में, हम लाइनों की तलाश करते हैं, और जब हम पहले एक को खोजते हैं, तो हम खोज को रोकते हैं और सही वापस लौटते हैं । इस तरह के एक जानवर-बल दृष्टिकोण काम करेगा, लेकिन यह बहुत धीमी गति से होगा, खासकर पुरानी मशीनों पर। अधिक कुशल तरीका है।
एक रेखा खींचने के लिए हमारे पास क्या विकल्प हो सकते हैं? आमतौर पर ये एक पंक्ति में एक ही प्रकार के दो चिप्स होते हैं। तीसरी चिप प्रकार में भिन्न है, लेकिन तीनों में से किसी के लिए भी नि: शुल्क दिशाओं में आदान-प्रदान किया जा सकता है। या एक ही प्रकार के दो चिप्स दूसरे प्रकार के एक चिप से अलग हो जाते हैं, और अब एक विनिमय 2 दिशाओं में हो सकता है।
आंकड़ा हमें इनमें से दो मामलों को दिखाता है जो 6 पैटर्न में विभाजित हैं।



अब यह जानते हुए कि केवल कुछ टेम्पलेट हैं जिन्हें हमें खोजने की आवश्यकता है, हम टॉप-डाउन प्रोग्रामिंग सिद्धांत का उपयोग करके लुकफॉरमैच फ़ंक्शन का उपयोग करना शुरू कर सकते हैं , और हम बाद में टेम्पलेट खोज फ़ंक्शन का ध्यान रखेंगे।
तस्वीर को देखते हुए, हम लाइन में प्रवेश करने वाले दो काले चिप्स और 3 चिप्स देखेंगे जो संभवतः एक ही प्रकार के हो सकते हैं। [0] [0] के रूप में दूर बाईं काली चिप को निरूपित करें। हम देखते हैं कि चिप [1] [0] एक ही प्रकार की है। यह उसी चिप को स्थिति [-1] [- 1] , [-2] [0] या [-1] [1] पर बना हुआ है । और दूसरी ओर [२] [- १] , [२] [१] और [३] [०] । इसलिए, हमें 6 स्थितियों में कम से कम एक चिप टाइप में मिलना चाहिए।



फ़ंक्शन को कॉल करते समय, हम इसे एक ही प्रकार के दो चिप्स की एक सरणी में पारित करेंगे, और तीसरे के आसपास चिप्स की एक सरणी, जिसमें से कम से कम एक को मेल खाना चाहिए। यह कुछ इस तरह दिखेगा।
मैचपार्टन ( कॉल, पंक्ति, [[1, 0]] , [[-2, 0], [- 1, -1], [- 1, 1], [2, -1], [2, 1], [3, 0]] )
हमें चित्र 2 में अन्य नमूना टेम्प्लेट के समान फ़ंक्शन की भी आवश्यकता है। 8.9। वे दोनों लंबवत हैं। LookForPossibles
फ़ंक्शन सभी बोर्ड स्थितियों को खोजता है।

//
public function lookForPossibles ( ) {
for ( var col: int = 0 ;col < 8 ;col++ ) {
for ( var row: int = 0 ;row < 8 ;row++ ) {

// ,
if ( matchPattern ( col, row, [ [ 1 , 0 ] ] , [ [ - 2 , 0 ] , [ - 1 ,- 1 ] , [ - 1 , 1 ] , [ 2 ,- 1 ] , [ 2 , 1 ] , [ 3 , 0 ] ] ) ) {
सच लौटना ;
}

// ,
if ( matchPattern ( col, row, [ [ 2 , 0 ] ] , [ [ 1 ,- 1 ] , [ 1 , 1 ] ] ) {
सच लौटना ;
}

// ,
if ( matchPattern ( col, row, [ [ 0 , 1 ] ] , [ [ 0 ,- 2 ] , [ - 1 ,- 1 ] , [ 1 ,- 1 ] , [ - 1 , 2 ] , [ 1 , 2 ] , [ 0 , 3 ] ] ) ) {
सच लौटना ;
}

// ,
if ( matchPattern ( col, row, [ [ 0 , 2 ] ] , [ [ - 1 , 1 ] , [ 1 , 1 ] ] ) ) {
सच लौटना ;
}
}
}

//
झूठे लौटना ;
}

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

public function matchPattern ( col,row:uint, mustHave, needOne: Array ) {
var thisType: int = grid [ col ] [ row ] . type ;
// ,

for ( var i: int = 0 ;i < mustHave. length ;i++ ) {
if ( ! matchType ( col+mustHave [ i ] [ 0 ] , row+mustHave [ i ] [ 1 ] , thisType ) ) {
झूठे लौटना ;
}
}

// ,
for ( i= 0 ;i < needOne. length ;i++ ) {
if ( matchType ( col+needOne [ i ] [ 0 ] , row+needOne [ i ] [ 1 ] , thisType ) ) {
सच लौटना ;
}
}
झूठे लौटना ;
}

मैचपैटर्न में सभी तुलना मैचटेप के माध्यम से की जाती है । चलो इसे एक अलग फ़ंक्शन बनाते हैं हम अक्सर उन चिप्स का संदर्भ लेंगे जो ग्रिड में नहीं हैं। उदाहरण के लिए, अगर हम को दे matchPattern col और पंक्ति [5] [0] , जांच चिप्स -1 का कोई अर्थ नहीं है, उदाहरण के 4 -1 के लिए, के रूप में वे नेट में नहीं आते हैं।
फ़ंक्शन यह जांच करेगा कि क्या चिप फ़ील्ड पर है, और यदि ऐसा है, तो यह आवश्यक प्रकार के साथ अपने प्रकार की तुलना करेगा।

public function matchType ( col,row, type : int ) {
// ,
if ( ( col < 0 ) || ( col > 7 ) || ( row < 0 ) || ( row > 7 ) ) return false ;
return ( grid [ col ] [ row ] . type== प्रकार ) ;
}

स्कोर और खेल का अंत findAndRemoveMatches
फ़ंक्शन में हमने खिलाड़ी को अंक जोड़ने के लिए addScore को बुलाया । यह सरल कार्य बिंदुओं को बताता है और स्क्रीन पर एक पाठ क्षेत्र के लिए आवश्यक डेटा स्थानांतरित करता है।

सार्वजनिक समारोह addScore ( numPoints: int ) {
gameScore + = numPoints;
MovieClip ( रूट ) । स्कोरडिसप्ले । पाठ = स्ट्रिंग ( गेमकोर ) ;
}

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

सार्वजनिक फ़ंक्शन एंडगेम ( ) {
// बैकग्राउंड
सेटिफ़्ड में शिफ्ट करेंइंडेक्स ( गेमसप्राइट , 0 ) ;
// गेम के अंतिम स्क्रीन पर जाएं
gotoAndStop ( "गेमओवर" ) ;
}

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

सार्वजनिक समारोह क्लीनअप ( ) {
ग्रिड = अशक्त ;
removeChild ( gameSprite ) ;
gameSprite = null ;
removeEventListener ( घटना। ENTER_FRAME , MovePgg ) ;
}

समयरेखा पर, क्लीनअप फ़ंक्शन playAgain बटन को बांधता है और एक नया गेम शुरू करने से पहले शुरू होता है।

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

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

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

युपीडी। एक छोटा सा जोड़।
आप खेल को और कैसे बेहतर बना सकते हैं। खैर, पहले संकेत। सभी ने शायद ऐसे मैकेनिक पर गेम में सुराग देखा। जब कोई खिलाड़ी लंबे समय तक कुछ नहीं करता है, तो दो चिप्स पलक झपकते हैं, जिसके साथ आप विनिमय कर सकते हैं। यह सब लुकफॉर पॉसिबल फ़ंक्शन का उपयोग करके किया जा सकता है। लेकिन कैसे, होमवर्क के रूप में रहेगा।
दूसरा, बोनस चिप्स। आप हमेशा हमारे फ्लैश ड्राइव में उसी प्रकार के बोनस की एक और परत शामिल कर सकते हैं जैसे कि सेलेक्ट करें । और बोनस संपत्ति को चिप में जोड़ें। और फिर मुझे लगता है कि यह स्पष्ट है कि इस चिप और अतिरिक्त बिंदुओं पर एक क्लिक का उपयोग कैसे किया जाए।
अब व्यक्तिगत ब्लॉग पर टिप्पणियों से सुझाए गए एक महत्वपूर्ण बिंदु। किताब में कहीं भी इसका उल्लेख नहीं है, लेकिन इस पल को याद नहीं करना बेहतर है।
1. सेटअपग्रिड फंक्शन में , हम गेम के शुरुआती फील्ड को लूप में बनाते हैं। और प्रत्येक चक्र में हम चिप्स जोड़ते हैं, इस बात की परवाह किए बिना कि क्षेत्र को खेलने योग्य बनाया गया था या नहीं।
2. AddPhew फ़ंक्शन में , हम प्रत्येक चिप के लिए एक श्रोता ( addEventListener ) लटकाते हैं। और जब इसे (चिप्स) निकाल दिया जाता है, तो इसे न निकालें ( RemoveEventListener )।
हमें यहां से क्या निकलना चाहिए? इस तरह की कमियां जल्द या बाद में मेमोरी लीक का कारण बनेंगी। हम अपने कोड में क्या सुधार कर सकते हैं?
1. हमारे सामने एक खेलने योग्य क्षेत्र होने पर चिप्स जोड़ें।
2. ध्वज का प्रयोग करें।
उदाहरण: object.addEventListener (Event.CLICK, handleClick false, 0, true) ;
चिप्स को हटाते समय, इसे हटाने का उपयोग करने की सिफारिश की जाती है ।

सुझावों के लिए धन्यवाद।