जावास्क्रिप्ट में यादृच्छिक द्वारा प्रबंधित

"एल्गोरिथ्म" यादृच्छिक रूप से उन्हें दोहराए बिना array से मूल्यों को लाने के लिए। विशेष रूप से, जेएस प्रशिक्षण के हिस्से के रूप में, मैंने इसे कक्षाओं और नामों को दोहराए बिना वर्णों के एक क्लासिक आरपीजी समूह (बर्बरियन, दाना, चोर, नाइट, पुजारी) को उत्पन्न करने के लिए उपयोग किया।



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

1. एक टेम्पलेट बनाएँ

वर्णों का एक समूह बनाने से पहले, आपको उनकी पीढ़ी के लिए एक टेम्पलेट निर्दिष्ट करने की आवश्यकता है। वास्तव में, यहाँ:

 function GamePlayer(n, r, l, p) { this.nick = n; this.role = r; this.level = l; this.portrait = p; } 

वास्तव में, यह फ़ंक्शन चर से वर्ण बनाएगा जिसके माध्यम से इसे कहा जाएगा। उदाहरण के लिए:

 var player1 = new GamePlayer("Power Ranger","barbarian","64","img/barbarian.jpg") 

अब, player1 एक विशिष्ट पोर्ट्रेट के साथ 64 पावर रेंजर player1 को स्तर देता है; हम player1.nick के पृष्ठ का उपयोग करके इसके किसी भी पैरामीटर को प्रदर्शित कर सकते हैं।

GamePlayer के मान (n, r, l, p) फ़ंक्शन में डेटा प्राप्त करने और प्राप्त करने के आदेश के लिए जिम्मेदार हैं। यदि उदाहरण में हम n और r स्वैप करते हैं, तो player1 शक्तिशाली player1 रेंजर player1 बनाए रखेगा, जो कार्य के लिए काफी अनुरूप नहीं है।

2. हम एरेज़ सेट करते हैं

हमारे स्वयं के चरित्र बनाने के लिए नहीं, बल्कि लगभग बेतरतीब ढंग से उन्हें उत्पन्न करने के लिए (जैसा कि हेडर में वादा किया गया है), सरणियों की आवश्यकता होती है जिसमें से हम इन समान वर्णों के मापदंडों को लेंगे। जैसा कि पहले ही ऊपर वर्णित है, हमारे पास केवल 4 पैरामीटर हैं: , , और ।


नाम के लिए ऐरे:

 var playerNames = ['Rabbit Helpless', 'Warm Dreaded Foal', 'Desire Kit', 'Angel Dusty', 'Sweety Frozen', 'Silver Heavy Wombat', 'Lost Puma', 'Vital Panda', 'Rolling Sun', 'Steel Runny', 'Young Fox', 'Needless Ruthless Volunteer', 'Chipmunk Cult', 'Indigo Puppy']; 

कोई और आगे जा सकता है और 2-3 घटकों से नाम उत्पन्न कर सकता है, लेकिन इस तरह के सुधार के लिए एल्गोरिथ्म में कुछ नया (समान यादृच्छिकता) शामिल नहीं है, और फिर यह सीखने की प्रक्रिया को जटिल बना देगा।


वर्ग के लिए सरणी:

 var playerRoles = ['barbarian', 'mage', 'rogue', 'knight', 'priest']; 

सब कुछ स्पष्ट है। कई string , जिसमें से हम पृष्ठ पर प्रदर्शित करने के लिए मानों का चयन करेंगे।


स्तर के लिए सरणी:

एक विशिष्ट उदाहरण में, मैं चाहता था कि समूह के सभी सदस्य 60 से 70 के स्तर के हों। लेकिन, चूंकि स्थितियां बदल सकती हैं, इसलिए 0 से 80 के स्तर तक एक सरणी बनाना आवश्यक था, जिसमें से वांछित मानों का चयन करना था। एक लूप द्वारा बनाया गया:

 var playerLevels = []; for (i = 0;i <= 80;i++) { console.log(i); playerLevels[i] = i; } 

परिणाम playerLevels की एक सरणी है, जिसमें से प्रत्येक सेल में स्वयं की संख्या के साथ एक int होता है।


चित्रों के लिए सरणी:

 var playerPortraits = ['img/barbarian.jpg', 'img/mage.jpg', 'img/rogue.jpg', img/knight.jpg', 'img/priest.jpg']; 

एक ही सिद्धांत, लेकिन पाठ के बजाय हम चित्रों के लिंक का उपयोग करते हैं। इसके अलावा, हम उन्हें वांछित div की background-image पैरामीटर (या वांछित चित्र के src पैरामीटर में, जिनके लिए यह अधिक सुविधाजनक है) में स्थानापन्न कर पाएंगे।

यह महत्वपूर्ण है कि playerPortraits array में चित्रों का क्रम playerPortraits सरणी में कक्षाओं के क्रम के समान है, फिर हम उन्हें उत्पन्न करने के लिए उसी random चर का उपयोग कर सकते हैं (ताकि चित्र वर्ग से मेल खाता हो)।

3. हम वर्ण उत्पन्न करते हैं

जैसा कि मैंने कहा, एक समूह में 5 वर्ण होने चाहिए। इसलिए, हम एक चक्र बनाते हैं:

 for (i = 0;i<=4;i++) { } 

लूप से पहले, हमारे भविष्य के पात्रों के लिए एक सरणी घोषित करना महत्वपूर्ण है:

 var players = [ ]; 

नाम पीढ़ी

अगला, बेतरतीब ढंग से नाम लाने के लिए एक यादृच्छिक चर बनाएँ:

 var namerand = Math.floor(Math.random() * playerNames.length) 

• Marh.random() उपयोग यादृच्छिक संख्या उत्पन्न करने के लिए किया जाता है;
• playerNames.length गुणा करें। playerNames.length ( playerNames सरणी की लंबाई) - सरणी में नामों की यादृच्छिक संख्या को सीमित करने के लिए;
• Math.floor - परिणामी संख्या को पूर्णांक में बदलने के लिए।

बारीकियों यह है कि Math.floor गोल हो जाता है, लेकिन चूंकि सरणियों में नंबरिंग 0 से जाती है, यह हमें सूट करती है।


कक्षा सृजन

सिद्धांत और कार्यान्वयन समान है:

 var rolerand = Math.floor(Math.random() * (playerRoles.length)); 

एकमात्र अंतर यह है कि कक्षाओं के लिए हम playerRoles सरणी का उपयोग करते हैं।


लेवल जनरेशन

 var levelrand = Math.floor(Math.random() * (70 - 60 + 1) + 60); 

एक निश्चित अंतराल में यादृच्छिक की गणना Math.random() * (max - min) + min के सूत्र के अनुसार होती है।

उदाहरण में, हमें 0 से 10 तक एक यादृच्छिक मिलता है, और फिर इसमें 60 जोड़ते हैं, 60 + 0 से 60 + 10 तक अंतराल प्राप्त करना (हमें इसकी आवश्यकता है)। Math.floor (ऊपर पढ़ें) के उपयोग के कारण एक इकाई जोड़ना आवश्यक है।


चरित्र निर्माण

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

 players[i] = new GamePlayer(playerNames[namerand], playerRoles[rolerand], playerLevels[levelrand], playerPortraits[rolerand]); 

वास्तव में, प्रत्येक चरित्र अपने क्रम संख्या के साथ players सरणी का एक तत्व बन जाता है। इसके पैरामीटर हैं:

• playerNames[namerand] - नाम, नामों का यादृच्छिक चयन ( namerand में namerand नंबर के तहत सेल);
• playerRoles[rolerand] - वर्ग, कक्षाओं से यादृच्छिक चयन;
• playerLevels[levelrand] -स्तर playerLevels[levelrand] - वर्ग, 60-70 की सीमा में यादृच्छिक स्तर का चयन;
• playerPortraits[rolerand] - पोर्ट्रेट से चित्र, यादृच्छिक चयन।

जैसा कि मैंने ऊपर उल्लेख किया है, पोर्ट्रेट और कक्षाओं के सरणियों को समान होना चाहिए ताकि "चित्र मेल खाता हो"; इसलिए हम दोनों मामलों में एक ही random उपयोग कर सकते हैं।


यादृच्छिक द्वारा प्रबंधित

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

 players[i] = new GamePlayer(playerNames[namerand], playerRoles[rolerand], playerLevels[levelrand], playerPortraits[rolerand]); playerNames.splice(namerand,1); playerRoles.splice(rolerand,1); playerPortraits.splice(rolerand,1); 

चरित्र को पैरामीटर सौंपने के तुरंत बाद, हम उनकी कोशिकाओं को संबंधित सरणियों से हटा देते हैं।

विशेष रूप से, playerNames.splice(namerand,1) playerNames ऑपरेशन का उपयोग करके playerNames सरणी से namerand संख्या के साथ सेल निकालता है। दशमलव बिंदु के बाद की इकाई बताती है कि निर्दिष्ट एक से शुरू होने पर कितनी कोशिकाओं को हटाने की आवश्यकता है; हमें केवल एक ही निर्दिष्ट सेल को हटाना होगा।

इसके अलावा, चक्र फिर से दोहराता है, और यदि यह सरणी के अंतिम सेल पर ठोकर खाई थी (तो हमने इसे 1 से कम कर दिया था) undefined लौट सकता था। लेकिन, चूंकि हमारा Math.random playerNames.length आदि का उपयोग करता है, यह सीधे सरणी की लंबाई पर निर्भर करता है, और केवल नए, गैर-डुप्लिकेट मानों का उत्पादन करेगा।

4. निष्कर्ष

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

कार्यान्वयन का प्रदर्शन (समान, थोड़ा अलग वर्ग)

मुझे उम्मीद है कि यह सामग्री किसी के लिए उपयोगी होगी और दिलचस्प समस्याओं को हल करने में उपयोगी होगी। जेएस में गुड लक!