ऐश एंटिटी सिस्टम ढांचे के लिए परिमित राज्य मशीन पैटर्न

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

नोट: मैं इकाई प्रणाली ढांचे (ES ढांचे) से मूल अवधारणाओं के नामों को बड़ा करूंगा - संभावित अस्पष्टताओं से बचने के लिए: सिस्टम , घटक, नोड , इकाई

ऐश एंटिटी सिस्टम ढांचे के लिए परिमित राज्य मशीन पैटर्न

परिमित राज्य मशीनें (एफएसएम) खेल देव में मुख्य निर्माणों में से एक है। गेम के दौरान, गेम ऑब्जेक्ट बार-बार अपने राज्यों को बदल सकते हैं और इन राज्यों का प्रभावी प्रबंधन बहुत महत्वपूर्ण है।

ES फ्रेमवर्क में FSM के साथ कठिनाई को एक वाक्य में व्यक्त किया जा सकता है - FSM ES ढांचे के साथ काम नहीं करता है। कोई भी ES फ्रेमवर्क एक डेटा-ओरिएंटेड प्रतिमान का उपयोग करता है जिसमें गेम इकाइयां OOP ऑब्जेक्ट्स को एनकोड नहीं करती हैं। इस प्रकार, आप एफएसएम या इसके वेरिएंट का उपयोग नहीं कर पाएंगे। सभी डेटा अवयवों में है, सभी तर्क सिस्टम में हैं।

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

स्टिक टेनिस को विकसित करते समय , मुझे राज्य प्रबंधन की समस्या का सामना करना पड़ा। इन राज्यों में बदलाव का क्रम कुछ इसी तरह का था ...

• परोसने के लिए तैयार करें
• दाखिल शुरू
• गेंद फेंक दो
• स्विंग रैकेट
• गेंद मारो
• हड़ताल पूर्ण करना
• अच्छी स्थिति में जाना
• गेंद पर प्रतिद्वंद्वी की प्रतिक्रिया
• अवरोधन करने के लिए गेंद चलती
• स्विंग रैकेट
• गेंद मारो
• हड़ताल पूर्ण करना
• अच्छी स्थिति में जाना
• गेंद पर प्रतिद्वंद्वी की प्रतिक्रिया
• आदि

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

उदाहरण

आइए एक खेल चरित्र की कल्पना करें - एक गार्ड। गार्ड कुछ मार्ग पर गश्त करता है, ध्यान से चारों ओर देख रहा है। जब किसी दुश्मन का पता लगाया जाता है, तो वह उस पर हमला करता है।

पारंपरिक ओओपी-उन्मुख एफएसएम में, हमें प्रत्येक राज्य के लिए कक्षाएं बनाना होगा।

public class PatrolState { private var guard : Character; private var path : Vector.<Point>; public function PatrolState( guard : Character, path : Vector.<Point> ) { this.guard = guard; this.path = path; } public function update( time : Number ) : void { moveAlongPath( time ); var enemy : Character = lookForEnemies(); if( enemy ) { guard.changeState( new AttackState( guard, enemy ) ); } } } 

 public class AttackState { private var guard : Character; private var enemy : Character; public function AttackState( guard : Character, enemy : Character ) { this.guard = guard; this.enemy = enemy; } public function update( time : Number ) : void { guard.attack( enemy ); if( enemy.isDead ) { guard.changeState( new PatrolState( guard, PatrolPathFactory.getPath( guard.id ) ); } } } 

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

 public class PatrolSystem extends ListIteratingSystem { public function PatrolSystem() { super( PatrolNode, updateNode ); } private function updateNode( node : PatrolNode, time : Number ) : void { moveAlongPath( node ); var enemy : Enemy = lookForEnemies( node ); if( enemy ) { node.entity.remove( Patrol ); var attack : Attack = new Attack(); attack.enemy = enemy; node.entity.add( attack ); } } } 

 public class AttackSystem extends ListIteratingSystem { public function AttackSystem() { super( AttackNode, updateNode ); } private function updateNode( node : PatrolNode, time : Number ) : void { attack( node.entity, node.attack.enemy ); if( node.attack.enemy.get( Health ).energy == 0 ) { node.entity.remove( Attack ); var patrol : Patrol = new Patrol(); patrol.path = PatrolPathFactory.getPath( node.entity.name ); node.entity.add( patrol ); } } } 

PatrolSystem संरक्षक चरित्र के व्यवहार के लिए जिम्मेदार होगा यदि PatrolComponent Component को इसमें शामिल किया गया है, और AttakSystem हमला व्यवहार के लिए जिम्मेदार होगा यदि AttackComponent Component को इसमें शामिल किया गया है। इन अवयवों को बदलकर, हम गार्ड चरित्र के राज्यों को स्विच कर सकते हैं।

ये कंपोनेंट्स और नोड्स कुछ इस तरह दिखेंगे ...

 public class Patrol { public var path : Vector.<Point>; } public class Attack { public var enemy : Entity; } public class Position { public var point : Point; } public class Health { public var energy : Number; } public class PatrolNode extends Node { public var patrol : Patrol; public var position : Position; } public class AttackNode extends Node { public var attack : Attack; } 

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

एक और उदाहरण

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

इसके लिए, निम्नलिखित दो जहाज स्थितियों की आवश्यकता थी:

1. जहाज जिंदा है
   • एक अंतरिक्ष यान की तरह दिखता है
   • खिलाड़ी इसे नियंत्रित कर सकते हैं
   • खिलाड़ी अपनी बंदूकों को गोली मार सकता है
   • जहाज क्षुद्रग्रहों से टकरा सकता है
2. जहाज मर चुका है
   • अंतरिक्ष में बहता मलबे जैसा दिखता है
   • खिलाड़ी इसे नियंत्रित नहीं कर सकता
   • खिलाड़ी अपनी बंदूकें नहीं मार सकता
   • जहाज क्षुद्रग्रहों से नहीं टकरा सकता
   • एक निश्चित समय के बाद जहाज को खेल से हटा दिया जाता है

संबंधित कोड जहां जहाज मर जाता है वह CollisionSystem में स्थित है। दूसरे राज्य के बिना, यह इस तरह दिखता है:

 for ( spaceship = spaceships.head; spaceship; spaceship = spaceship.next ) { for ( asteroid = asteroids.head; asteroid; asteroid = asteroid.next ) { if ( Point.distance( asteroid.position.position, spaceship.position.position ) <= asteroid.position.collisionRadius + spaceship.position.collisionRadius ) { creator.destroyEntity( spaceship.entity ); break; } } } 

कोड यह देखने के लिए जाँच करता है कि क्या जहाज एक क्षुद्रग्रह से टकराया था, और यदि ऐसा होता है, तो जहाज को खेल से हटा देता है। दूसरी ओर, GameManager एक ऐसी स्थिति को संभालता है जब खेल में कोई स्थान नहीं होता है और एक नया निर्माण करता है। यदि सभी "जीवन" समाप्त हो जाते हैं - खेल का अंत। तो - बस जहाज को खेल से हटाने के बजाय, हमें इसका राज्य बदलना होगा - उड़ान मलबे को दिखाने के लिए। आइए कोशिश करते हैं ...

हम स्पेसशिप इकाई से केवल MotionControls और GunControls घटकों को हटाकर खिलाड़ी का नियंत्रण ले सकते हैं। साथ ही, हमें मोशन और गन कंपोनेंट्स को हटा देना चाहिए क्योंकि वे अभी भी उपयुक्त नियंत्रकों के बिना उपयोग नहीं किए जाते हैं। यानी हम उपरोक्त कोड बदलते हैं:

 for ( spaceship = spaceships.head; spaceship; spaceship = spaceship.next ) { for ( asteroid = asteroids.head; asteroid; asteroid = asteroid.next ) { if ( Point.distance( asteroid.position.position, spaceship.position.position ) <= asteroid.position.collisionRadius + spaceship.position.collisionRadius ) { spaceship.entity.remove( MotionControls ); spaceship.entity.remove( Motion ); spaceship.entity.remove( GunControls ); spaceship.entity.remove( Gun ); break; } } } 

फिर हमें जहाज (मलबे के लिए) की उपस्थिति को बदलने और टकराव से निपटने को रद्द करने की आवश्यकता है:

 for ( spaceship = spaceships.head; spaceship; spaceship = spaceship.next ) { for ( asteroid = asteroids.head; asteroid; asteroid = asteroid.next ) { if ( Point.distance( asteroid.position.position, spaceship.position.position ) <= asteroid.position.collisionRadius + spaceship.position.collisionRadius ) { spaceship.entity.remove( MotionControls ); spaceship.entity.remove( Motion ); spaceship.entity.remove( GunControls ); spaceship.entity.remove( Gun ); spaceship.entity.remove( Collision ); spaceship.entity.remove( Display ); spaceship.entity.add( new Display( new SpaceshipDeathView() ) ); break; } } } 

और अंत में, हमें निश्चित अवधि के बाद जहाज के मलबे को हटाने को सुनिश्चित करने की आवश्यकता है। इसके लिए हमें एक नई प्रणाली और घटक की आवश्यकता है:

 public class DeathThroes { public var countdown : Number; public function DeathThroes( duration : Number ) { countdown = duration; } } public class DeathThroesNode extends Node { public var death : DeathThroes; } public class DeathThroesSystem extends ListIteratingSystem { private var creator : EntityCreator; public function DeathThroesSystem( creator : EntityCreator ) { super( DeathThroesNode, updateNode ); this.creator = creator; } private function updateNode( node : DeathThroesNode, time : Number ) : void { node.death.countdown -= time; if ( node.death.countdown <= 0 ) { creator.destroyEntity( node.entity ); } } } 

हम गेम में डेथट्रॉसेस सिस्टम को बहुत शुरुआत से जोड़ते हैं, और सही समय पर यह एंटिटी के "मौत" का जवाब देगा। यह अंतरिक्ष यान के सार में डेथट्रोज़ घटक को जोड़ने के लिए बनी हुई है।

 for ( spaceship = spaceships.head; spaceship; spaceship = spaceship.next ) { for ( asteroid = asteroids.head; asteroid; asteroid = asteroid.next ) { if ( Point.distance( asteroid.position.position, spaceship.position.position ) <= asteroid.position.collisionRadius + spaceship.position.collisionRadius ) { spaceship.entity.remove( MotionControls ); spaceship.entity.remove( Motion ); spaceship.entity.remove( GunControls ); spaceship.entity.remove( Gun ); spaceship.entity.remove( Collision ); spaceship.entity.remove( Display ); spaceship.entity.add( new Display( new SpaceshiopDeathView() ) ); spaceship.entity.add( new DeathThroes( 5 ) ); break; } } } 

नतीजतन, हमें अंतरिक्ष यान की आवश्यक स्थिति मिलती है। अंतरिक्ष यान के घटकों को "फेरबदल" द्वारा राज्यों के बीच बहुत संक्रमण सुनिश्चित किया गया था।

एक घटक सेट में एक विशिष्ट स्थिति एनकैप्सुलेटेड है।

Entity System Architecture का मुख्य नियम यह है कि Entity State को अवयवों के एक समूह में समझाया जाता है। यदि आप एक इकाई के व्यवहार को बदलना चाहते हैं, तो आपको अवयवों के सेट को बदलना होगा। बदले में घटकों के सेट को बदलने से सिस्टम का सेट बदल जाएगा - और सार का व्यवहार बदल जाएगा।

FSM के लिए मानकीकृत कोड

एफएसएम के साथ काम करने में आसानी के लिए, मैंने कक्षाओं के एक समान सेट को फ्रेमवर्क में जोड़ा - मानक राज्य मशीन कक्षाएं । इन वर्गों का एक सेट नए राज्यों को निर्धारित करने और उन्हें प्रबंधित करने में मदद करेगा।

FSM EntityStateMachine वर्ग का एक उदाहरण है। जब आप एक उदाहरण बनाते हैं, तो आप उसे एंटिटी का एक लिंक देते हैं, जिसमें से यह प्रबंधन करेगा। EntityStateMachine का उदाहरण आमतौर पर इकाई में कुछ घटक में संग्रहीत किया जाता है और इस प्रकार किसी भी सिस्टम की पहुंच होती है।

 var stateMachine : EntityStateMachine = new EntityStateMachine( guard ); 

FSM राज्यों को संग्रहीत करता है, और इन राज्यों को EntityStateMachine.changeState () विधि से कॉल करके बदला जा सकता है। प्रत्येक विशिष्ट स्थिति को एक स्ट्रिंग (नाम) द्वारा पहचाना जाता है, जो कि स्टेट के साथ जुड़ा होता है जब इसे EntityStateMachine.changeState (StateName) कहते समय बनाया और उपयोग किया जाता है।

 var patrolState : EntityState = stateMachine.createState( "patrol" ); var attackState : EntityState = stateMachine.createState( "attack" ); 

एफएसएम के लिए जिम्मेदार राज्य को क्या कहा जाता है

1. आवश्यक घटक जोड़ता है जब इकाई इस स्थिति में प्रवेश करती है;
2. वर्तमान स्थिति से बाहर निकलने पर पहले जोड़े गए घटकों को हटाता है।

EntityStateMachine.add () विधि निर्धारित राज्य के लिए आवश्यक घटक के प्रकार को सेट करती है और इस घटक को बनाने के तरीके को निर्दिष्ट करने वाले नियमों का पालन करती है।

 var patrol : Patrol = new Patrol(); patrol.path = PatrolPathFactory.getPath( node.entity.name ); patrolState.add( Patrol ).withInstance( patrol ); attackState.add( Attack ); 

चार मानक विधियाँ हैं:

unitState.add (प्रकार: कक्षा);
किसी भी निर्देश के बिना FSM इस प्रकार के घटक का एक नया उदाहरण बनाएगा, इसके बाद इकाई के लिए। और जब भी आप इस अवस्था में लौटेंगे, इसे दोहराया जाएगा।
UnitState.add (प्रकार: वर्ग) .withType (अन्य प्रकार: कक्षा);
यह संकेत इस स्थिति में प्रवेश करने पर प्रत्येक बार अन्य प्रकार का एक नया उदाहरण बनाता है। अन्य प्रकार टाइप प्रकार या एक्सटेंशन प्रकार का होना चाहिए
UnitState.add (प्रकार: वर्ग) .withInstance (उदाहरण: *);
यह विधि घटक स्थिति का एक ही उदाहरण का उपयोग करना संभव बनाता है जब वह इस स्थिति पर लौटता है।

और अंत में

UnitState.add (प्रकार: वर्ग) .withSingleton ();
या
UnitState.add (प्रकार: वर्ग) .withSingleton (अन्य प्रकार: कक्षा);
एक सिंगलटन बनाएगा और हर बार जब वह इस राज्य में वापस आएगा, तो उसका उपयोग करेगा। यह withInstance पद्धति का उपयोग करने के समान है, लेकिन withSingleton विधि कक्षा को तब तक नहीं रोक सकती है जब तक कि जरूरत न हो। यदि अन्य प्रकार निर्दिष्ट नहीं है, तो टाइप प्रकार का एक सिंगलटन बनाया जाता है। यदि अन्य प्रकार निर्दिष्ट किया गया है, तो यह टाइप प्रकार का होना चाहिए, या इसका विस्तार करना चाहिए।

अंत में, आप IComponentProvider इंटरफ़ेस को लागू करके घटक को स्वयं परिभाषित कर सकते हैं
UnitState.add (प्रकार: वर्ग) .withProvider (प्रदाता: IComponentProvider);
IComponentProvider इंटरफ़ेस निम्नानुसार परिभाषित किया गया है

 public interface IComponentProvider { function getComponent() : *; function get identifier() : *; } 

GetComponent विधि घटक का एक उदाहरण देता है। पहचानकर्ता संपत्ति का उपयोग दो प्रदाताओं की तुलना करने के लिए किया जाता है ताकि यह सुनिश्चित हो सके कि वे एक ही घटक को वापस करते हैं। घटक के प्रतिस्थापन को बाहर करने के लिए यह आवश्यक है यदि दो अलग-अलग राज्य एक ही घटक का उपयोग करते हैं।

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

वापस उदाहरण के लिए

यदि हम इन नए उपकरणों को एक स्पेसशिप के साथ उदाहरण के लिए लागू करते हैं, तो कोड निम्न रूप लेगा

 var fsm : EntityStateMachine = new EntityStateMachine( spaceshipEntity ); fsm.createState( "playing" ) .add( Motion ).withInstance( new Motion( 0, 0, 0, 15 ) ) .add( MotionControls ) .withInstance( new MotionControls( Keyboard.LEFT, Keyboard.RIGHT, Keyboard.UP, 100, 3 ) ) .add( Gun ).withInstance( new Gun( 8, 0, 0.3, 2 ) ) .add( GunControls ).withInstance( new GunControls( Keyboard.SPACE ) ) .add( Collision ).withInstance( new Collision( 9 ) ) .add( Display ).withInstance( new Display( new SpaceshipView() ) ); fsm.createState( "destroyed" ) .add( DeathThroes ).withInstance( new DeathThroes( 5 ) ) .add( Display ).withInstance( new Display( new SpaceshipDeathView() ) ); var spaceshipComponent : Spaceship = new Spaceship(); spaceshipComponent.fsm = fsm; spaceshipEntity.add( spaceshipComponent ); fsm.changeState( "playing" ); 

परिणामस्वरूप, वर्तमान राज्य के परिवर्तन को यथासंभव सरल बनाया जाएगा:

 for ( spaceship = spaceships.head; spaceship; spaceship = spaceship.next ) { for ( asteroid = asteroids.head; asteroid; asteroid = asteroid.next ) { if ( Point.distance( asteroid.position.position, spaceship.position.position ) <= asteroid.position.collisionRadius + spaceship.position.collisionRadius ) { spaceship.spaceship.fsm.changeState( "destroyed" ); break; } } }