ईसीएस का उपयोग करके गेम की विशेषताएं: शूटर को प्राथमिक चिकित्सा किट जोड़ें

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

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

हमारे ईसीएस में गेमस्टेट में दो भाग होते हैं: नियमबुक और वर्ल्डस्टेट। रूलबुक घटकों का एक सेट है जो एक मैच के दौरान नहीं बदलता है। सभी स्थैतिक डेटा को वहां संग्रहीत किया जाता है (हथियारों / पात्रों की विशेषताओं, टीमों की संरचना) और क्लाइंट को केवल एक बार भेजा जाता है - गेम सर्वर पर प्राधिकरण के दौरान।

एक सरल उदाहरण पर विचार करें: एक चरित्र को स्पॉन करें और दो जॉयस्टिकों का उपयोग करके इसे 2 डी स्पेस में स्थानांतरित करें। सबसे पहले, घटकों को घोषित करें।

यह खिलाड़ी को परिभाषित करता है और चरित्र दृश्य के लिए आवश्यक है:

[Component] public class Player { } 

अगला घटक एक नया चरित्र बनाने का अनुरोध है। इसमें दो फ़ील्ड होते हैं: वर्ण स्पॉन टाइम (टिक में) और इसकी आईडी:

 [Component] public class PlayerSpawnRequest { public int SpawnTime; public unit PlayerId; } 

अंतरिक्ष में वस्तु के उन्मुखीकरण का घटक:

 [Component] public class Transform { public Vector2 Position; public float Rotation; } 

घटक जो वस्तु की वर्तमान गति को संग्रहीत करता है:

 [Component] public class Movement { public Vector2 Velocity; public float RotateToAngle; } 

घटक जो खिलाड़ी के इनपुट (गति जॉयस्टिक वेक्टर और चरित्र रोटेशन जॉयस्टिक वेक्टर) को संग्रहीत करता है:

 [Component] public class Input { public Vector2 MoveVector; public Vector2 RotateVector; } 

चरित्र की स्थिर विशेषताओं के साथ घटक (यह नियमबुक में संग्रहीत किया जाएगा, क्योंकि यह एक बुनियादी विशेषता है और गेम पेज के दौरान नहीं बदलता है):

 [Component] public class PlayerStats { public float MoveSpeed; } 

सिस्टम में एक सुविधा को विघटित करते समय, हम अक्सर एकल जिम्मेदारी के सिद्धांत द्वारा निर्देशित होते हैं: प्रत्येक प्रणाली को एक और केवल एक फ़ंक्शन को पूरा करना होगा।

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

 public class SpawnPlayerSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.SpawnAvatarRequest); foreach (var avatarRequest in gs.WorldState.SpawnAvatarRequest) { if (avatarRequest.Value.SpawnTime == gs.Time) { // create new entity with player ID var playerEntity = gs.WorldState.CreateEntity(avatarRequest.Value.PlayerId); // add components to determinate player behaviour playerEntity.AddPlayer(); playerEntity.AddTransform(Vector2.zero, 0); playerEntity.AddMovement(Vector2.zero, 0); // delete player spawn request deleter.Delete(avatarRequest.Key); } } } } 

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

 MovementControlSystem public class MovementControlSystem : ExecutableSystem { public override void Execute(GameState gs) { var playerStats = gs.RuleBook.PlayerStats[1]; foreach (var pair in gs.Input) { var movement = gs.WorldState.Movement[pair.Key]; movement.Velocity = pair.Value.MoveVector.normalized * playerStats.MoveSpeed; movement.RotateToAngle = Math.Atan2(pair.Value.RotateVector.y, pair.Value.RotateVector.x); } } } 

अगला आंदोलन प्रणाली है:

 public class MovementSystem : ExecutableSystem { public override void Execute(GameState gs) { foreach (var pair in gs.WorldState.Movement) { var transform = gs.WorldState.Transform[pair.Key]; transform.Position += pair.Value.Velocity * GameState.TickDurationSec; } } } 

ऑब्जेक्ट के रोटेशन के लिए जिम्मेदार प्रणाली:

 public class RotationSystem : ExecutableSystem { public override void Execute(GameState gs) { foreach (var pair in gs.WorldState.Movement) { var transform = gs.WorldState.Transform[pair.Key]; transform.Angle = pair.Value.RotateToAngle; } } } 

MoveSSystem और RotationSystem केवल ट्रांसफॉर्म और मूवमेंट घटकों के साथ काम करते हैं। वे खिलाड़ी के सार से स्वतंत्र हैं। यदि हमारे खेल में मूवमेंट और ट्रांसफॉर्म घटकों के साथ अन्य इकाइयां दिखाई देती हैं, तो आंदोलन तर्क भी उनके साथ काम करेगा।

उदाहरण के लिए, एक प्राथमिक चिकित्सा किट जोड़ें जो स्पॉन के साथ एक सीधी रेखा में चलेगी और चयन करते समय, चरित्र के स्वास्थ्य को फिर से भर देगी। घटक घोषित करें:

 [Component] public class Health { public uint CurrentHealth; public uint MaxHealth; } [Component] public class HealthPowerUp { public uint NextChangeDirection; } [Component] public class HealthPowerUpSpawnRequest { public uint SpawnRequest; } [Component] public class HealthPowerUpStats { public float HealthRestorePercent; public float MoveSpeed; public float SecondsToChangeDirection; public float PickupRadius; public float TimeToSpawn; } 

हम वहां जीवन की अधिकतम संख्या जोड़कर चरित्र के आँकड़ों के घटक को संशोधित करते हैं:

 [Component] public class PlayerStats { public float MoveSpeed; public uint MaxHealth; } 

अब हम वर्ण स्पॉन प्रणाली को संशोधित करते हैं ताकि चरित्र अधिकतम स्वास्थ्य के साथ दिखाई दे:

 public class SpawnPlayerSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.SpawnAvatarRequest); var playerStats = gs.RuleBook.PlayerStats[1]; foreach (var avatarRequest in gs.WorldState.SpawnAvatarRequest) { if (avatarRequest.Value.SpawnTime <= gs.Time) { // create new entity with player ID var playerEntity = gs.WorldState.CreateEntity(avatarRequest.Value.PlayerId); // add components to determinate player behaviour playerEntity.AddPlayer(); playerEntity.AddTransform(Vector2.zero, 0); playerEntity.AddMovement(Vector2.zero, 0); playerEntity.AddHealth(playerStats.MaxHealth, playerStats.MaxHealth); // delete player spawn request deleter.Delete(avatarRequest.Key); } } } } 

तब हम अपनी प्राथमिक चिकित्सा किट की स्पॉन प्रणाली की घोषणा करते हैं:

 public class SpawnHealthPowerUpSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.HealthPowerUpSpawnRequest); var healthPowerUpStats = gs.RoolBook.healthPowerUpStats[1]; foreach (var spawnRequest in gs.WorldState.HealthPowerUpSpawnRequest) { // create new entity var powerUpEntity = gs.WorldState.CreateEntity(); // add components to determine healthPowerUp behaviour powerUpEntity.AddHealthPowerUp((uint)(healthPowerUpStats.SecondsToChangeDirection * GameState.Hz)); playerEntity.AddTransform(Vector2.zero, 0); playerEntity.AddMovement(healthPowerUpStats.MoveSpeed, 0); // delete player spawn request deleter.Delete(spawnRequest.Key); } } } 

और प्राथमिक चिकित्सा किट की गति को बदलने के लिए एक प्रणाली। सरल बनाने के लिए, प्राथमिक चिकित्सा किट हर कुछ सेकंड में दिशा बदल देगी:

 public class HealthPowerUpMovementSystem : ExecutableSystem { public override void Execute(GameState gs) { var healthPowerUpStats = gs.RoolBook.healthPowerUpStats[1]; foreach (var pair in gs.WorldState.HealthPowerUp) { var movement = gs.WorldState.Movement[pair.Key]; if(pair.Value.NextChangeDirection <= gs.Time) { pair.Value.NextChangeDirection = (uint) (healthPowerUpStats.SecondsToChangeDirection * GameState.Hz); movement.Velocity *= -1; } } } } 

चूंकि हमने पहले ही खेल में वस्तुओं को स्थानांतरित करने के लिए एक मूवमेंट सिस्टम की घोषणा की है, इसलिए हमें केवल स्पीड वेक्टर, हर एन सेकंड को बदलने के लिए हेल्थपॉवर यूपीओवमेंटमेंट सिस्टम की आवश्यकता है।

अब हम प्राथमिक चिकित्सा किट का चयन और चरित्र के लिए एचपी की अभिवृद्धि को समाप्त करते हैं। हमें प्राथमिक चिकित्सा किट का चयन करने के बाद चरित्र को प्राप्त होने वाले जीवन की संख्या को संग्रहीत करने के लिए एक और सहायक घटक की आवश्यकता होगी।

 [Component] public class HealthToAdd { public int Health; public Entity Target; } 

और हमारी शक्ति को हटाने के लिए एक घटक:

 [Component] public class DeleteHealthPowerUpRequest { } 

हम एक ऐसी प्रणाली लिखते हैं जो प्राथमिक चिकित्सा किट के चयन की प्रक्रिया करती है:

 public class HealthPowerUpPickUpSystem : ExecutableSystem { public override void Execute(GameState gs) { var healthPowerUpStats = gs.RoolBook.healthPowerUpStats[1]; foreach(var powerUpPair in gs.WorldState.HealthPowerUp) { var powerUpTransform = gs.WorldState.Transform[powerUpPair.Key]; foreach(var playerPair in gs.WorldState.Player) { var playerTransform = gs.WorldState.Transform[playerPair.Key]; var distance = Vector2.Distance(powerUpTransform.Position, playerTransform.Position) if(distance < healthPowerUpStats.PickupRadius) { var healthToAdd = gs.WorldState.Health[playerPair.Key].MaxHealth * healthPowerUpStats.HealthRestorePercent; var entity = gs.WorldState.CreateEntity(); entity.AddHealthToAdd(healthToAdd, gs.WorldState.Player[playerPair.Key]); var powerUpEnity = gs.WorldState[powerUpPair.Key]; powerUpEnity.AddDeleteHealthPowerUpRequest(); break; } } } } } 

सिस्टम सभी सक्रिय पावर-अप के माध्यम से जाता है और खिलाड़ी के लिए दूरी की गणना करता है। यदि कोई खिलाड़ी चयन त्रिज्या के भीतर है, तो सिस्टम दो अनुरोध घटक बनाता है:

HealthToAdd - एक चरित्र में जीवन जोड़ने के लिए "अनुरोध";
DeleteHealthPowerUpRequest - प्राथमिक चिकित्सा किट को हटाने के लिए "अनुरोध" करें।

एक ही प्रणाली में जीवन की सही संख्या क्यों नहीं जोड़ते? हम इस तथ्य से आगे बढ़ते हैं कि खिलाड़ी न केवल प्राथमिक चिकित्सा किट से, बल्कि अन्य स्रोतों से भी एचपी प्राप्त करता है। इस मामले में, प्राथमिक चिकित्सा किट चयन प्रणाली और चरित्र की जीवन प्रणाली को अलग करना अधिक समीचीन है। इसके अलावा, यह एकल जिम्मेदारी सिद्धांत के साथ अधिक सुसंगत है।

हम चरित्र में जान डालने की प्रणाली को लागू करते हैं:

 public class HealingSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.HealthToAdd); foreach(var healtToAddPair in gs.WorldState.HealthToAdd) { var healthToAdd = healtToAddPair.Value.Health; var health = healtToAddPair.Value.Target.Health; health.CurrentHealth += healthToAdd; health.CurrentHealth = Mathf.Clamp(health.CurrentHealth, 0, health.MaxHealth); deleter.Delete(healtToAddPair.Key); } } } 

सिस्टम HealthToAdd के सभी घटकों से गुजरता है , लक्ष्य लक्ष्य इकाई के स्वास्थ्य घटक में जीवन की आवश्यक संख्या की गणना करता है। यह इकाई स्रोत और लक्ष्य के बारे में कुछ नहीं जानती है और काफी सार्वभौमिक है। इस प्रणाली का उपयोग न केवल चरित्र के जीवन की गणना के लिए किया जा सकता है, बल्कि किसी भी वस्तु के लिए जो जीवन की उपस्थिति और उनके उत्थान को शामिल करता है।

प्राथमिक चिकित्सा किट के साथ सुविधा को लागू करने के लिए, यह अंतिम प्रणाली को जोड़ने के लिए बनी हुई है: इसके चयन के बाद प्राथमिक चिकित्सा किट हटाने की प्रणाली।

 public class DeleteHealthPowerUpSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.DeleteHealthPowerUpReques); foreach(var healthRequest in gs.WorldState.DeleteHealthPowerUpReques) { var id = healthRequest.Key; gs.WorldState.DelHealthPowerUp(id); gs.WorldState.DelTransform(id); gs.WorldState.DelMovement(id); deleter.Delete(id); } } } 

HealthPowerUpPickUpSystem प्राथमिक चिकित्सा किट को हटाने का अनुरोध करता है। DeleteHealthPowerUpSystem सिस्टम ऐसे सभी अनुरोधों से गुजरता है और प्राथमिक चिकित्सा किट के सार से संबंधित सभी घटकों को हटा देता है।

हो गया। हमारे उदाहरणों से सभी प्रणालियों को लागू किया जाता है। ईसीएस के साथ काम करने का एक बिंदु है - सभी प्रणालियों को क्रमिक रूप से निष्पादित किया जाता है और यह आदेश महत्वपूर्ण है।

हमारे उदाहरण में, सिस्टम का क्रम निम्नानुसार है:

 _systems = new List<ExecutableSystem> { new SpawnPlayerSystem(), new SpawnHealthPowerUpSystem(), new MovementControlSystem(), new HealthPowerUpMovementSystem(), new MovementSystem(), new RotationSystem(), new HealthPowerUpPickUpSystem(), new HealingSystem(), new DeleteHealthPowerUpSystem() }; 

सामान्य स्थिति में, नई संस्थाएं और घटक बनाने के लिए जिम्मेदार सिस्टम पहले आते हैं। फिर उपचार प्रणाली, और अंत में हटाने और सफाई प्रणाली।

उचित अपघटन के साथ, ECS में बहुत लचीलापन होता है। हां, हमारा कार्यान्वयन सही नहीं है, लेकिन यह आपको थोड़े समय में सुविधाओं को लागू करने की अनुमति देता है, और आधुनिक मोबाइल उपकरणों पर अच्छा प्रदर्शन भी करता है। आप ECS के बारे में अधिक यहाँ पढ़ सकते हैं:

• हमने अपना ECS कैसे और क्यों लिखा ।
• गेम सर्वर पर ब्राउज़र में हम स्व-लिखित ईसीएस को कैसे डिबग करते हैं ।
• ECS की तरह, C # जॉब सिस्टम और SRP आर्किटेक्चर को बदल रहे हैं ।
• एकता ECS ।
• एकता, ईसीएस और ऑल-ऑल। उदाहरणों में ईसीएस पर अच्छा लेख।