कण मॉडलिंग में कण प्रणाली (2)

हम 04/07/2014 ( भीड़ मॉडलिंग में कण प्रणाली ) से बातचीत जारी रखते हैं।

इस भाग में मैं जोड़ता हूं:

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

कोड लिखने की शैली के बारे में एक छोटी टिप्पणी (पहले भाग के पाठकों के लिए):

• मत भूलो, कोड को एक ला स्यूडोकोड लिखा जाता है - इस तथ्य के बावजूद कि यह काम कर रहा है, दृश्यता को सबसे आगे रखा जाता है, न कि कार्यक्षमता और "शुद्धता"
• मैं कक्षा के माध्यम से एप्लिकेशन के आधार वर्ग ( MainWailines_1 ) का विस्तार कर रहा हूं ( MainWailines_2 ) - फिर से स्पष्टता के लिए, और इसलिए विभिन्न लेखों से टिप्पणियां नहीं मिलाने के लिए (यानी, वास्तव में, वास्तव में, मैं इस मामले में विरासत के साथ नहीं खेलूंगा)
• मैं दूसरे भाग में पहले भाग से टिप्पणियां हटाता हूं - सभी उसी के लिए, हां, स्पष्टता के लिए
• बहुत सारी तस्वीरें - समाधान के विकास को स्पष्ट करने और यह दिखाने के लिए कि पूर्णता की कोई सीमा नहीं है

धीमे चरित्र

हम MainWaylines_2.setupEmitterForMonsterArrows () विधि लिखते हैं। यह वास्तव में पूर्व MainWaylines_1.setupEmitter () की कॉपी-पेस्ट है । मैंने सिर्फ पुरानी टिप्पणियों को हटा दिया है, और उन्हें केवल वहीं छोड़ दिया है जहां परिवर्तन हैं।

protected function setupEmitterForMonsterArrows():void { var emitter:Emitter2D = new Emitter2D(); //   -   1     emitter.counter = new Steady(1); var wayline:Wayline = _waylines[0]; 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( Arrow, [10] ) ); emitter.addAction( new DeathZone( new RectangleZone( -30, -30, stage.stageWidth+60, stage.stageHeight + 60 ), true ) ); emitter.addAction( new Move() ); emitter.addAction( new RotateToDirection() ); //      ,      , //        action // emitter.addAction( new MinimumDistance( 7, 600 ) ); //    emitter.addAction( new ActionResistance(.1)); emitter.addAction( new FollowWaylines(_waylines) ); var renderer:DisplayObjectRenderer = new DisplayObjectRenderer(); addChild( renderer ); renderer.addEmitter( emitter ); //   emitterWaylinesForMonsterArrows = emitter; emitterWaylinesForMonsterArrows.start(); } 

अब विस्तार करें और MainWaylines_2.setup चलाएं ()

 override protected function setup(e:Event=null):void { super.setup(); //        setupEmitterForMonsterArrows(); } 

हमें इस तरह की एक तस्वीर मिलती है। बड़े तीर छोटे लोगों के साथ विलय होते हैं - समानांतर में मौजूद हैं

चारों ओर धीमी गति से तीर

छोटी चीजों के लिए बड़े तीर के चारों ओर जाने के लिए, आपको उन्हें एक कमांड देने की आवश्यकता है। MainWaylines_2.setup () में एक पंक्ति जोड़ें, जहां एंटीग्रेविटस कण प्रणाली पुस्तकालय (शांत पुस्तकालय, सही?) से एक और मानक कार्रवाई है।

 override protected function setup(e:Event=null):void { super.setup(); //        setupEmitterForMonsterArrows(); //   action   "  " //  (!)   ,      -       emitterWaylines.addAction( new Antigravities(emitterWaylinesForMonsterArrows, -400000) ); } 

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



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

एक पंक्ति के लिए MainWaylines_2.setupWaylines () को फिर से लिखें

 override protected function setupWaylines():void { _waylines = []; var w:Number = stage.stageWidth; var h:Number = stage.stageHeight; 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)]; var fitline:FitLine = new FitLine(points); var path:Path = new Path(fitline.fitPoints); /* *   .  40,  25 * *   ,    ,           * ,   ,         */ var step:Number = path.length / 25; 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); } } 

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

संपादित करें MainWaylines_2.setupEmitterForMonsterArrows () , एमिटर के लाइनज़ोन को 20 से कम करना (प्रत्येक पक्ष पर 10 पिक्सेल)

 emitter.addInitializer( new Position( new LineZone( new Point(wayline.x - (wayline.radius-10)*Math.cos(wayline.rotation), wayline.y - (wayline.radius-10)*Math.sin(wayline.rotation)), new Point(wayline.x + (wayline.radius-10)*Math.cos(wayline.rotation), wayline.y + (wayline.radius-10)*Math.sin(wayline.rotation)) ) ) ); 

अब बड़े तीर के पीछे ट्रैफिक जाम बहुत छोटा है

विस्फोट (शरीर के बिखरने के साथ)

निकायों के बिखरने के एनीमेशन के लिए - एक नया एमिटर बनाएं

 protected function setupEmitterForExplosion():void { var emitter:Emitter2D = new Emitter2D(); //    -    emitter.addAction( new Move() ); //      ,       -     emitter.addAction( new SpeedLimit(40)); //      -  emitter.addAction( new Friction(40) ); //    -   (      ) emitter.addAction( new DeathZone( new RectangleZone( -30, -10, stage.stageWidth+40, stage.stageHeight + 20 ), true ) ); //   var renderer:DisplayObjectRenderer = new DisplayObjectRenderer(); addChild( renderer ); renderer.addEmitter( emitter ); //   emitterExplosion = emitter; emitterExplosion.start(); } 

हम MainEaylines_2.setup () में MouseEvent.MOUSE_DOWN की सदस्यता लेते हैं - हम इन घटनाओं पर विस्फोट उत्पन्न करेंगे

 stage.addEventListener(MouseEvent.MOUSE_DOWN, handleMouseDown); 

हम विस्फोट (ई) को तुरंत क्यों नहीं कहते हैं ; ? वहां आप विस्फोट के एनीमेशन को जोड़ सकते हैं, जिसके बाद परिणाम उत्पन्न होंगे

 private function handleMouseDown(e:MouseEvent):void { explosion(e); } 

अब धमाका ही हुआ

 private function explosion(e:MouseEvent):void { if(emitterWaylines == null){ return; } if(emitterExplosion == null){ return; } //   var explRadius:int = 30; //      // (        ,   dot-     ) var particleOrigin:Particle2D; var particleClone:Particle2D; var particlePoint:Point = new Point(); //    ... var explPoint:Point = new Point(e.stageX, e.stageY); //     var particles:Array = emitterWaylines.particlesArray; var length:int = particles.length; //      for(var p:int=0; p<length; p++) { particleOrigin = particles[p]; particlePoint.x = particleOrigin.x; particlePoint.y = particleOrigin.y; // ,        if(Point.distance(explPoint, particlePoint) < explRadius) { /* *  ,    -         *       -    */ particleClone = particleOrigin.clone(emitterExplosion.particleFactory) as Particle2D; particleClone.angVelocity = -5 + Math.random() * 10; /* *    Arrow ( ) -    ActionScript  ,      * !      , *         emitterWaylines   * -       renderer.removeChild() * *    .        . *      ( , )   , *       ( -      ) */ particleClone.image = new Arrow(4, 0xff0000); //       emitterExplosion.addParticle(particleClone); //      particleOrigin.isDead = true; } } /* *  action    * *   , ,   -     , *    ,         (.     ). * *    -     :       * *  ,        ,    ... *   -     */ var explosion:Explosion = new Explosion(10000, explPoint.x, explPoint.y, 100); emitterExplosion.addAction(explosion); /* *          -        *       Emitter2D.update(.2) -      */ //         emitterExplosion.update(0.2); //  action Explosion -     emitterExplosion.removeAction(explosion); } 

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



आवश्यक परिवर्तनों का सार सरल है - एक निश्चित समय के बाद, कण को ​​पिछली धारा में "वापस" करना आवश्यक है।
1. सबसे पहले, MainWaylines_2.setupEmitterForExplosion () में परिवर्तन करें:

 protected function setupEmitterForExplosion():void { var emitter:Emitter2D = new Emitter2D(); ... //  action  "" .   ,  . // .    ,       emitterExplosion.addAction( new Age() ); ... //   "   ",      ""  emitterExplosion.addEventListener(ParticleEvent.PARTICLE_DEAD, handleParticleDeadFromEmitterExplosion); } 

2. अब MainWaylines_2.explosion () में परिवर्तन जोड़ें

 private function explosion(e:MouseEvent):void { ... //      for(var p:int=0; p<length; p++) { ... // ,        if(Point.distance(explPoint, particlePoint) < explRadius) { particleClone = particleOrigin.clone(emitterExplosion.particleFactory) as Particle2D; particleClone.angVelocity = -5 + Math.random() * 10; /* * action Age()   ,     *        ,  "" *           */ particleClone.lifetime = 3; particleClone.age = 0; ... } } ... } 

चलाएँ। हम प्राप्त करते हैं।



परिणाम:

1. दो प्रकार की इकाइयाँ: छोटी और बड़ी
2. छोटी इकाइयां बड़ी होती हैं
3. विस्फोट छोटी इकाइयों को प्रभावित करते हैं (इसे छर्रे होने दें, जो टैंकों को प्रभावित नहीं करता है - बड़े तीर)
4. छोटे लोग "कैंटस" से उबरने के बाद फिर से सामान्य धारा में लौट आते हैं

स्पष्ट विपक्ष

1. गैर-महाकाव्य उच्च गति शूटर
2. कम एफपीएस

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

मुझे लगता है कि अनुकूलन के लिए क्षमता है, और विचारणीय है

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

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

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

पुनश्च: अगले भाग में मैं शूटर की मौत को जोड़ दूंगा (आखिरकार, विस्फोटों ने मार डाला)
मैं एमिटर की सेटिंग के साथ खेलूंगा - मुझे महाकाव्य चाहिए।

PPS: प्रश्न। मैं एनिमेटेड 3D वर्णों से स्प्राइट शीट बनाने का एक आसान तरीका सीखना चाहता हूं। जैसा कि मैं इसे अपने लिए देखता हूं:

1. एक एनिमेटेड चरित्र है
2. मैं एक निश्चित सॉफ्टवेयर उत्पाद में लगभग निम्नलिखित पैरामीटर सेट करना चाहता हूं:
   
   • आकार
   • कैमरा कोण
   • फ्रेम की संख्या
3. आउटपुट - स्प्राइट शीट

मुझे मत बताओ कि कौन सा रास्ता देखना है? शायद इस तरह के एक काम तकनीक का एक विस्तृत वर्णन है?
अग्रिम धन्यवाद।

PPPS: MainWaylines_2.explosion () विधि के कोड में दो पंक्तियों को जोड़ा गया: यह विस्फोट से पहले कण वेग वैक्टर को रीसेट करता है - यह अधिक प्राकृतिक दिखता है

 protected function explosion(e:MouseEvent):void { ... particleClone.velX = 0; particleClone.velY = 0; ... }