वेब / यूआई जेएस देव के रूप में समझने की कोशिश करने से मुझे मदद मिल सकती है। इसके अलावा, भाषा अज्ञेयवाद में बहुत दूर मत जाओ। अन्य भाषाओं में स्थापित बहुत सारे पैटर्न अध्ययन के लायक हैं, लेकिन जेएस में इसके लचीलेपन के कारण बहुत अलग तरीके से लागू किया जा सकता है या भाषा की निंदनीय प्रकृति के कारण वास्तव में आवश्यक नहीं है। आप कुछ अवसरों को उड़ा सकते हैं यदि आप जेएस की अपनी सोच को एक ही शास्त्रीय ओओपी-उन्मुख भाषा की सीमाओं के समान सेट के रूप में लिखते हैं।
सबसे पहले, "OOP का उपयोग न करें" कारक पर, याद रखें कि जावास्क्रिप्ट ऑब्जेक्ट अन्य भाषाओं की तुलना में playdough की तरह हैं और आपको वास्तव में एक cascading-inheritance योजना दुःस्वप्न बनाने के लिए अपने रास्ते से बाहर जाना होगा क्योंकि JS वर्ग नहीं है। -बेड और कंपोजिंग इसके लिए स्वाभाविक रूप से बहुत अधिक आता है। यदि आप अपने जेएस में कुछ मूर्खतापूर्ण वर्ग या प्रोटोटाइप हैंड-मी-डाउन सिस्टम लागू कर रहे हैं, तो इसे खाई पर विचार करें। जेएस में हम क्लोजर, प्रोटोटाइप का उपयोग करते हैं, और हम कैंडी जैसे कार्यों को पास करते हैं। यह घृणित और गंदी और गलत है, लेकिन शक्तिशाली, संक्षिप्त है और यही वह तरीका है जो हमें पसंद है।
विरासत के भारी दृष्टिकोणों को वास्तव में डिज़ाइन पैटर्न में एक विरोधी पैटर्न के रूप में समझा जाता है और अच्छे कारण के रूप में जो कोई भी वर्ग या वर्ग जैसी संरचनाओं के 15+ स्तर से नीचे चला गया है, जहां यह पता लगाने की कोशिश की जाती है कि एक विधि का पर्दाफाश संस्करण कहां है? से आ रहा था आपको बता सकता है।
मुझे नहीं पता कि इतने सारे प्रोग्रामर ऐसा करना पसंद करते हैं (विशेष रूप से जावा लोग किसी कारणवश जावास्क्रिप्ट लिख रहे हैं), लेकिन यह अत्यधिक होने पर भी भयानक, अवैध और पूरी तरह से अस्वीकार्य है। इनहेरिटेंस यहाँ और वहाँ ठीक है, लेकिन वास्तव में जेएस में आवश्यक नहीं है। ऐसी भाषाओं में जहां यह एक अधिक आकर्षक शॉर्टकट है, इसे वास्तव में अधिक शाब्दिक वास्तुकला की चिंताओं के लिए आरक्षित किया जाना चाहिए न कि एक शाब्दिक मॉडलिंग योजनाओं जैसे कि एक विरासत श्रृंखला के माध्यम से एक ज़ोंबी कार्यान्वयन की रूपरेखा बनाना, जिसमें एक बनीरीबबिट शामिल है क्योंकि यह काम हुआ। यह अच्छा कोड पुन: उपयोग नहीं है। यह एक रखरखाव दुःस्वप्न है।
जेएस देव एंटिटी / घटक / सिस्टम आधारित इंजन के रूप में मुझे डिजाइन की चिंताओं को कम करने के लिए एक प्रणाली / पैटर्न के रूप में हड़ताल करते हैं और फिर अत्यधिक दानेदार स्तर पर कार्यान्वयन के लिए वस्तुओं की रचना करते हैं। दूसरे शब्दों में, बच्चे का जावास्क्रिप्ट जैसी भाषा में खेलना। लेकिन मुझे यह देखने दें कि क्या मैं इसे पहले सही ढंग से ग्रूम कर रहा हूं।
इकाई - विशिष्ट चीज जिसे आप डिजाइन कर रहे हैं। हम उचित संज्ञा की दिशा में अधिक बात कर रहे हैं (लेकिन वास्तव में, बिल्कुल नहीं)। Not सीन ’नहीं, बल्कि ro इंट्रोएरेवेलीन’। IntroAreaLevelOne किसी तरह के एक दृश्य बॉक्स के अंदर बैठ सकता है, लेकिन हम कुछ विशिष्ट चीजों पर ध्यान केंद्रित कर रहे हैं जो संबंधित चीजों से भिन्न होती हैं। कोड में, एक इकाई वास्तव में सिर्फ एक नाम (या आईडी) है जो सामान के एक समूह से बंधा है जिसे उपयोगी होने के लिए इसे लागू या स्थापित (घटकों) की आवश्यकता है।
अवयव - एक इकाई की जरूरत के प्रकार। ये सामान्य संज्ञाएं हैं। वॉकिंगएनिमेशन की तरह। WalkingAnimation के भीतर हम और अधिक विशिष्ट हो सकते हैं, जैसे "शंबलिंग" (लाश और पौधों के राक्षसों के लिए अच्छा विकल्प), या "चिकनवल्कर" (रिवर्स-ज्वाइंट एड -209इश रोबोट-प्रकार के लिए महान)। नोट: यह निश्चित नहीं है कि इस तरह एक 3 डी मॉडल के प्रतिपादन से कैसे कम हो सकता है - इसलिए शायद एक बकवास उदाहरण है, लेकिन मैं एक जेएस समर्थक से अधिक एक अनुभवी खेल देवता हूं। जेएस में मैं घटकों के साथ एक ही बॉक्स में मैपिंग तंत्र लगाऊंगा। अपने आप में घटक तर्क पर हल्के होने की संभावना रखते हैं और आपके सिस्टम को बताए जाने वाले रोडमैप के अधिक होने पर क्या सिस्टम लागू करने की आवश्यकता है (ईसीएस में मेरे प्रयास में कुछ घटक सिर्फ संपत्ति सेट के संग्रह हैं)। एक बार एक घटक स्थापित होने के बाद, यह '
सिस्टम - असली प्रोग्राममी मांस यहाँ है। AI सिस्टम बनाया गया है और जुड़ा हुआ है, रेंडरिंग हासिल किया गया है, एनिमेशन सीक्वेंस स्थापित किए गए हैं, आदि ... मैं बाहर नकल कर रहा हूं और ज्यादातर इन कल्पनाओं को छोड़ रहा हूं लेकिन उदाहरण में System.AI गुणों का एक गुच्छा लेता है और एक फ़ंक्शन को थूक देता है जो ईवेंट हैंडलर को ऑब्जेक्ट में जोड़ने के लिए उपयोग किया जाता है जो अंततः कार्यान्वयन में उपयोग किया जाता है। System.AI के बारे में महत्वपूर्ण बात यह है कि इसमें कई घटक प्रकार शामिल हैं। आप एक घटक के साथ सभी एआई सामान को सॉर्ट कर सकते हैं लेकिन ऐसा करने के लिए चीजों को दानेदार बनाने की बात को गलत समझना है।
माइंड्स गोल्स: हम गैर-डिजाइनरों के लिए कुछ प्रकार के GUI इंटरफ़ेस में प्लग-इन करना आसान बनाना चाहते हैं, एक प्रतिमान के भीतर घटकों को अधिकतम और मिलान करके विभिन्न प्रकार के सामान को आसानी से ट्विस्ट कर सकते हैं, जो उन्हें समझ में आता है, और हम इससे दूर होना चाहते हैं लोकप्रिय मनमाने ढंग से कोड योजनाएं जो संशोधित करने या बनाए रखने की तुलना में बहुत आसान हैं।
तो जेएस में, शायद कुछ इस तरह। खेल देवता कृपया मुझे बताएं कि क्या मुझे यह बहुत गलत लगा है:
//I'm going with simple objects of flags over arrays of component names
//easier to read and can provide an opt-out default
//Assume a genre-bending stealth assassin game
//new (function etc... is a lazy way to define a constructor and auto-instantiate
var npcEntities = new (function NpcEntities(){
//note: {} in JS is an object literal, a simple obj namespace (a dictionary)
//plain ol' internal var in JS is akin to a private member
var default={ //most NPCs are humanoids and critters - why repeat things?
speedAttributes:true,
maneuverAttributes:true,
combatAttributes:true,
walkingAnimation:true,
runningAnimation:true,
combatAnimation:true,
aiOblivious:true,
aiAggro:true,
aiWary:true, //"I heard something!"
aiFearful:true
};
//this. exposes as public
this.zombie={ //zombies are slow, but keep on coming so don't need these
runningAnimation:false,
aiFearful:false
};
this.laserTurret={ //most defaults are pointless so ignore 'em
ignoreDefault:true,
combatAttributes:true,
maneuverAttrubtes:true, //turning speed only
};
//also this.nerd, this.lawyer and on and on...
//loop runs on instantiation which we're forcing on the spot
//note: it would be silly to repeat this loop in other entity collections
//but I'm spelling it out to keep things straight-forward.
//Probably a good example of a place where one-level inheritance from
//a more general entity class might make sense with hurting the pattern.
//In JS, of course, that would be completely unnecessary. I'd just build a
//constructor factory with a looping function new objects could access via
//closure.
for(var x in npcEntities){
var thisEntity = npcEntities[x];
if(!thisEntity.ignoreDefaults){
thisEntity = someObjectXCopyFunction(defaults,thisEntity);
//copies entity properties over defaults
}
else {
//remove nonComponent property since we loop again later
delete thisEntity.ignoreDefaults;
}
}
})() //end of entity instantiation
var npcComponents = {
//all components should have public entityMap properties
//No systems in use here. Just bundles of related attributes
speedAttributes: new (function SpeedAttributes(){
var shamblingBiped = {
walkingAcceleration:1,
topWalking:3
},
averageMan = {
walkingAcceleration:3,
runningAcceleration:4,
topWalking: 4,
topRunning: 6
},
programmer = {
walkingAcceleration:1,
runningAcceleration:100,
topWalking:2
topRunning:2000
}; //end local/private vars
//left is entity names | right is the component subcategory
this.entityMap={
zombie:shamblingBiped,
lawyer:averageMan,
nerd:programmer,
gCostanza:programmer //makes a cameo during the fire-in-nursery stage
}
})(), //end speedAttributes
//Now an example of an AI component - maps to function used to set eventHandlers
//functions which, because JS is awesome we can pass around like candy
//I'll just use some imaginary systems on this one
aiFearful: new (function AiFearful(){
var averageMan = Systems.AI({ //builds and returns eventSetting function
fearThreshold:70, //%hitpoints remaining
fleeFrom:'lastAttacker',
tactic:'avoidIntercept',
hazardAwareness:'distracted'
}),
programmer = Systems.AI({
fearThreshold:95,
fleeFrom:'anythingMoving',
tactic:'beeline',
hazardAwareness:'pantsCrappingPanic'
});//end local vars/private members
this.entityMap={
lawyer:averageMan,
nerd:averageMan, //nerds can run like programmers but are less cowardly
gCostanza:programmer //makes a cameo during the fire-in-nursery stage
}
})(),//and more components...
//Systems.AI is general and would get called for all the AI components.
//It basically spits out functions used to set events on NPC objects that
//determine their behavior. You could do it all in one shot but
//the idea is to keep it granular enough for designers to actually tweak stuff
//easily without tugging on developer pantlegs constantly.
//e.g. SuperZombies, zombies, but slightly tougher, faster, smarter
}//end npcComponents
function createNPCConstructor(npcType){
var components = npcEntities[npcType],
//objConstructor is returned but components is still accessible via closure.
objConstructor = function(){
for(var x in components){
//object iteration <property> in <object>
var thisComponent = components[x];
if(typeof thisComponent === 'function'){
thisComponent.apply(this);
//fires function as if it were a property of instance
//would allow the function to add additional properties and set
//event handlers via the 'this' keyword
}
else {
objConstructor.prototype[x] = thisComponent;
//public property accessed via reference to constructor prototype
//good for low memory footprint among other things
}
}
}
return objConstructor;
}
var npcBuilders= {}; //empty object literal
for (var x in npcEntities){
npcConstructors[x] = createNPCConstructor(x);
}
अब किसी भी समय आपको एनपीसी की आवश्यकता होती है, आप के साथ निर्माण कर सकते हैं npcBuilders.<npcName>();
एक GUI npcEntities और घटक वस्तुओं में प्लग कर सकता है और डिजाइनरों को पुरानी संस्थाओं को जोड़ने या बस मिश्रण और मेल घटकों द्वारा नई इकाइयां बनाने की अनुमति दे सकता है (हालांकि गैर-डिफ़ॉल्ट घटकों के लिए वहां कोई तंत्र नहीं है लेकिन विशेष घटकों को मक्खी में जोड़ा जा सकता है। जब तक इसके लिए एक परिभाषित घटक था तब तक कोड।