भीड़ मॉडलिंग में कण प्रणाली

मेरे पास आने वाले कई विचार, किसी ने पहले ही लागू कर दिए हैं या जल्द ही महसूस करेंगे (इंटरनेट से उद्धरण)

2001 में वापस, मैं, वास्तविक समय की रणनीतियों का एक प्रशंसक, खेल "Cossacks" से मारा गया था। नक्शा घूमते हुए GIANT की भीड़ द्वारा मारा गया। यह हड़ताली था कि ये भीड़ तत्कालीन कम-शक्ति वाले कंप्यूटरों पर तेज दौड़ती थी। लेकिन उस समय मैं एक एम्बुलेंस पर काम कर रहा था, मैं प्रोग्रामिंग से बहुत दूर था, इसलिए, यह तब प्रशंसा तक सीमित था।

पहले से ही हमारे समय में, मैं एक ही संख्या में चलती इकाइयों के साथ एक खिलौना बनाना चाहता था - ताकि "महाकाव्य" बस छत से गुजर जाए (!)। और इसलिए कि ये इकाइयाँ केवल चलती नहीं हैं, बल्कि बाहरी रूप से (!) चलती हैं। और इसलिए (सबसे महत्वपूर्ण बात), यह सब वैभव कमजोर मोबाइल प्लेटफार्मों पर काम करता है।

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

मुझे यकीन है कि बहुत सारी सिफारिशें, साहित्य और यहां तक ​​कि कार्यान्वयन भी हैं। लेकिन मुझे कुछ "असंदिग्ध" में दिलचस्पी थी, जिसे "मोबाइल फोन" के लिए एक साधारण खिलौने में इस्तेमाल किया जा सकता है और "घुटने पर" इकट्ठा किया जा सकता है। यानी सस्ते और हंसमुख, और सबसे महत्वपूर्ण बात - यह मेरे लिए स्पष्ट है (!)।


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

विचार सुनने के बाद पैदा हुआ सार इस प्रकार था।

1. सभी (सभी) एक खेल में विभिन्न "व्यक्ति के प्रेरक इरादों" को वैक्टर (व्यवस्था, भय, घृणा, आलस्य, बहरापन, जड़ता ...) की एक प्रणाली द्वारा वर्णित किया जाना चाहिए। एक खेल चक्र (या हर दसवें, यह कोई फर्क नहीं पड़ता) के दौरान, इन वैक्टर के साथ विभिन्न जोड़तोड़ किए जाते हैं। सभी जोड़तोड़ों का परिणाम वैक्टर का योग होगा, जो सरलतम मामले में चरित्र के आंदोलन की दिशा निर्धारित करेगा (सैकड़ों में से एक, या यहां तक ​​कि हजारों)।
2. प्रत्येक "व्यक्तिगत" में वैक्टर का एक ही सेट होना चाहिए - संगणना के मानकीकरण के लिए। फिर एक छोटा, बार-बार कोड का टुकड़ा - एक पाइपलाइन - एक भीड़ में एक व्यक्ति "व्यक्ति" के व्यवहार को निर्धारित कर सकता है। कन्वेयर की सुंदरता यह है कि यह उसके लिए बिल्कुल मायने नहीं रखता है "वह" जिसे वह संसाधित करता है - एक मोटा आदमी, एक रोलिंग व्हील, एक लाश ... उसके लिए मुख्य बात "उद्देश्यों" का एक सेट है। इसके लिए धन्यवाद, हमें निकास पर न केवल एक भीड़ मिलती है, बल्कि एक विविध (!) भीड़ है।

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

ऐसा उपकरण पाया गया - एक कण प्रणाली (कण प्रणाली) । मैंने FLINT को चुना।

1. कण प्रणाली प्रोटोटाइप के लिए आदर्श है
2. कण प्रणाली के अंदर की गणना शास्त्रीय यांत्रिकी के नियमों पर आधारित हैं - अर्थात। आजकल, पहले से ही असंख्य विविध एल्गोरिदम हैं जो आपकी स्वयं की प्रोग्रामिंग आवश्यकताओं के अनुकूल हो सकते हैं।
3. तृतीय-पक्ष लाइब्रेरी से कोई भी रेंडर कण प्रणाली से खराब हो सकता है
4. कण प्रणाली के इस संस्करण को रिचर्ड लॉर्ड (यह एक अलग गीत है) द्वारा एंटिटी सिस्टम ढांचे ऐश के लेखक द्वारा लिखा गया था।

किसी कण प्रणाली के विशिष्ट कार्यान्वयन के लिए बुनियादी उपकरणों का संक्षेप में वर्णन करें:

1. emitter ( Emitter2D ) - वास्तव में वर्ग का एक उदाहरण है, जो निर्दिष्ट मापदंडों के अनुसार कणों की पीढ़ी के लिए जिम्मेदार है, और आगे "रखरखाव"
2. Emitter2D.addInitializer (initializer) - एक विधि जिसके द्वारा "गुण" emitter में जोड़े जाते हैं, जो कि उत्पन्न होने पर कणों को सौंपा जाएगा।
3. Emitter2D.addAction (कार्रवाई) - इस पद्धति का उपयोग करके, कण नियंत्रण नियमों को एमिटर में जोड़ा जाता है, जो उनके जीवन के दौरान कणों पर लागू होगा।

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

उफ्फ ... प्रस्तावना का अंत। लेकिन यह मुझे लगता है कि यह महत्वपूर्ण है।

विचार का क्रियान्वयन

आइए सबसे सरल कार्य से शुरू करें:

1. किसी भी जटिलता का एक मार्ग उत्पन्न करते हैं
2. वर्ण दिए गए मार्ग का अनुसरण करते हैं, जबकि
   
   • एक दूसरे पर "फिट" नहीं है
   • यात्रा की दिशा में "देखो"
   
   

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

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



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

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

package waylines.waypoints { import flash.geom.Point; import flash.geom.Line; public class Wayline extends Waypoint { public var rotation:Number; public var line:Line; public function Wayline(x : Number = 0, y : Number = 0, segmentLength : Number = 40, rotation:Number=0, strength : Number = 1, attenuationPower : Number = 0, epsilon : Number = 1) { super(x, y, segmentLength/2, strength, attenuationPower, epsilon); this.rotation = rotation; this.line = new Line(new Point(x - (radius * Math.cos(rotation)), y - (radius * Math.sin(rotation))), new Point(x + (radius * Math.cos(rotation)), y+(radius * Math.sin(rotation)))); } } } 

फिर नोडल बिंदुओं से मिलकर एक पथ उत्पन्न करते हैं

 protected function setupWaylines():void { _waylines = []; var w:Number = stage.stageWidth; var h:Number = stage.stageHeight; /* * 1.      ,         * 2.        ,    -  ,     */ //var points:Array = [new Point(-9,h*.6), new Point(w*.3,h*.3), new Point(w*.5,h*.25), new Point(w*.6,h*.45), new Point(w*.7,h*.7), new Point(w*.8, h*.75), new Point(w*.9, h*.6), new Point(w*1.3, h*.5)]; var points:Array = [new Point(-9,h*.4), new Point(w*.3,h*.4), new Point(w*.5,h*.1), new Point(w*.8,h*.1), new Point(w*.8,h*.9), new Point(w*.5, h*.9), new Point(w*.3, h*.8), new Point(-40, h*.8)]; /* * : * 1.  Wayline        * 2.         * 3.       * : *       http://silin.su/#AS3,  * 1. FitLine - ,  ""   * 2. Path - ,    ,   ,   .  -    . * 3. ""        */ var fitline:FitLine = new FitLine(points); var path:Path = new Path(fitline.fitPoints); /* * ! -          -    . * ,     ""    ,  "" ,      . *   -   ,     ,   ...   */ var step:Number = path.length / 40; /* *      - ,    "  "? * ..   ,        -     */ var strength:Number = 100; //     for(var i:int=0; i<path.length; i+=step) { //         var segmentLength:int = 60;//*Math.random()+10; var pathpoint:PathPoint = path.getPathPoint(i); var wayline:Wayline = new Wayline(pathpoint.x, pathpoint.y, segmentLength, pathpoint.rotation-Math.PI/2, strength); _waylines.push(wayline); } } 

2. वर्ण दिए गए मार्ग का अनुसरण करते हैं, जबकि

• एक दूसरे पर "फिट" नहीं है
• यात्रा की दिशा में "देखो"

यह आइटम कण प्रणाली की सेटिंग का उपयोग करके ही लागू किया जाता है। यानी - एमिटर को कॉन्फ़िगर करें

 protected function setupEmitter():void { // ---      ,          ------------- var emitter:Emitter2D = new Emitter2D(); //   -       emitter.counter = new Steady(60); //    var wayline:Wayline = _waylines[0]; //     LineZone  ,      "" Wayline emitter.addInitializer( new Position( new LineZone( new Point(wayline.x - wayline.radius*Math.cos(wayline.rotation), wayline.y - wayline.radius*Math.sin(wayline.rotation)), new Point(wayline.x + wayline.radius*Math.cos(wayline.rotation), wayline.y + wayline.radius*Math.sin(wayline.rotation)) ) ) ); // ,        //emitter.addInitializer( new ImageClass( ArrowBitmap, [4] ) ); emitter.addInitializer( new ImageClass( Arrow, [4] ) ); // ---  actions,        --------------------------------------------- //       (!) . ..       // 1.  ( ) -   -      // 2.  -    (   ,    " ") // 3.   -   -     ,   -  //     action   ,         "" action FollowWaylines emitter.addAction( new DeathZone( new RectangleZone( -30, -30, stage.stageWidth+60, stage.stageHeight + 60 ), true ) ); // new Move() -       . .. -   ,      action emitter.addAction( new Move() ); // ,         emitter.addAction( new RotateToDirection() ); //      emitter.addAction( new MinimumDistance( 7, 600 ) ); //    action    (  "" SpeedLimit,      -      ) emitter.addAction( new ActionResistance(.4)); //  "" action,          emitter.addAction( new FollowWaylines(_waylines) ); //   //var renderer:BitmapRenderer = new BitmapRenderer(new Rectangle(0, 0, stage.stageWidth, stage.stageHeight)); var renderer:DisplayObjectRenderer = new DisplayObjectRenderer(); //     addChild( renderer ); //       renderer.addEmitter( emitter ); //   emitterWaylines = emitter; emitterWaylines.start(); } 

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

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

कोड Google कोड पर उपलब्ध है।

पुनश्च: अगले भाग में मैं कार्य को जटिल बनाना चाहता हूं। मैं जोड़ें:

1. विस्फोट (शरीर के बिखरने के साथ)
2. धीमे अक्षर (ये बड़े तीर होंगे)
3. चारों ओर धीमी गति से तीर

PPS: किसी अन्य लेख में मैं कोड को जावास्क्रिप्ट में पोर्ट करता हूं (मुझे थोड़ा अनुभव मिलेगा ताकि मुझे बहुत समय तक मार न पड़े)