Kullanıcı dostu fakat yine de esnek olan bileşen tabanlı bir varlık sistemi için hangi tasarımlar var?

Bir süredir bileşen tabanlı varlık sistemine ilgi duydum ve sayısız makaleyi okudum ( Insomiac oyunları , oldukça standart olan Hiyerarşinizi Geliştirin , T-Machine , Chronoclast ... sadece birkaç isim).

Hepsinin dışarısında bir şey varmış gibi görünüyor:

Entity e = Entity.Create();
e.AddComponent(RenderComponent, ...);
//do lots of stuff
e.GetComponent<PositionComponent>(...).SetPos(4, 5, 6);

Ve paylaşılan veri fikrini getirirseniz (bu, şimdiye kadar gördüğüm en iyi tasarımdır, her yerde verileri kopyalamamak açısından)

e.GetProperty<string>("Name").Value = "blah";

Evet, bu çok verimli. Ancak, tam olarak okumak veya yazmak kolay değildir; sana karşı çok tuhaf ve sana karşı çalışan bir duygu.

Şahsen şöyle bir şey yapmak istiyorum:

e.SetPosition(4, 5, 6);
e.Name = "Blah";

Tabii ki, bu tür bir tasarıma ulaşmanın tek yolu, Varlık-> NPC-> Düşman-> FlyingEnemy-> FlyingEnemyWithAHatTarihine göre bu tasarımdan kaçınmaya çalışır.

Bu tür bir bileşen sistemi için hala esnek olan, ancak bir kullanıcı dostu olma düzeyi koruyan bir tasarım görmüş olan var mı? Ve bu konuda, veri depolama alanını (muhtemelen en zor olanı) iyi bir şekilde aşmayı başarır mı?

Kullanıcı dostu fakat yine de esnek olan bileşen tabanlı bir varlık sistemi için hangi tasarımlar var?

Unity'nin yaptığı şeylerden biri, ortak bileşenlere daha kullanıcı dostu erişim sağlamak için ana oyun nesnesindeki bazı yardımcı erişim sağlayıcıları sağlamaktır.

Örneğin, konumunuzu bir Dönüştür bileşeninde saklamış olabilirsiniz. Örneğinizi kullanarak şöyle bir şey yazmanız gerekir

e.GetComponent<Transform>().position = new Vector3( whatever );

Ancak Birlik'te bu basitleştirildi

e.transform.position = ....;

transformKelimenin tam anlamıyla temel GameObjectsınıftaki basit bir yardımcı yöntem ( Entitydurumunuzdaki sınıf) nerede ?

Transform transform
{ 
    get { return this.GetComponent<Transform>(); }
}

Birlik, oyun nesnesinde alt bileşenleri yerine bir "Ad" özelliği belirlemek gibi başka birkaç şey de yapar.

Şahsen, paylaşılan veriye göre tasarım fikrinden hoşlanmıyorum. Bir değişken yerine isme göre özelliklere erişmek ve kullanıcının aynı zamanda ne tür bir şey olduğunu bilmek zorunda olması bana gerçekten eğilimli görünüyor. Unity, kardeş bileşenlere erişmek GameObject transformiçin Componentsınıf içindeki özelliklerle aynı yöntemleri kullanmalarıdır . Yani yazdığınız herhangi bir bileşen herhangi bir şeyi basitçe yapabilir:

var myPos = this.transform.position;

Konuma erişmek için. Bu transformmülkün böyle bir şey yaptığı yerde

Transform transform
{
    get { return this.gameObject.GetComponent<Transform>(); }
}

Tabii ki, sadece söylemekten biraz daha ayrıntılı e.position = whatever, ama alışırsın ve genel özellikler kadar kötü görünmüyor. Ve evet, müşteri bileşenleriniz için bunu dolambaçlı yoldan yapmak zorunda kalacaksınız, ancak fikir, tüm ortak "motor" bileşenleriniz (işleyiciler, çarpıştırıcılar, ses kaynakları, dönüşümler, vb.) Kolay erişicilere sahip olmasıdır.

Varlık nesneleriniz için bir tür Arayüz sınıfının iyi olacağını düşünüyorum. Bir işletmenin uygun değerin bir bileşenini tek bir konumda içerdiğinden emin olmak için hata işlemeyi yapabilir, böylece değerlere eriştiğiniz her yerde yapmak zorunda kalmazsınız. Alternatif olarak, bileşen tabanlı bir sistemle yaptığım tasarımların çoğu, doğrudan bileşenlerle ilgileniyorum, örneğin konumsal bileşenlerini talep ediyorum ve sonra o bileşenin özelliklerine doğrudan erişiyorum / güncelliyorum.

Yüksek düzeyde çok basit olan sınıf, söz konusu varlığı üstlenir ve aşağıdaki bileşen parçalarına kullanımı kolay bir arayüz sağlar:

public class EntityInterface
{
    private Entity entity { get; set };
    public EntityInterface(Entity e)
    {
        entity = e;
    }

    public Vector3 Position
    {
        get
        {
            return entity.GetProperty<Vector3>("Position");
        }
        set
        {
            entity.GetProperty<Vector3>("Position") = value;
        }
    }
}

Python'da, 'setPosition' bölümünü Varlık üzerinde e.SetPosition(4,5,6)bir __getattr__işlev ilan ederek engelleyebilirsiniz . Bu işlev, bileşenler arasında yinelenebilir ve uygun yöntemi veya özelliği bulabilir ve onu geri döndürebilir, böylece işlev çağrısı veya ataması doğru yere gider. Belki de C # benzer bir sisteme sahiptir, ancak statik olarak yazılmasından dolayı mümkün olmayabilir - e.setPositione, arayüzde bir yere ayar yapmamışsa muhtemelen derleyemez.

Belki de tüm varlıklarınızın, kendilerine ekleyebileceğiniz tüm bileşenler için bir istisna oluşturan saplama yöntemleriyle ilgili arayüzleri uygulamalarını sağlayabilirsiniz. Sonra addComponent'i çağırdığınızda, o bileşenin arayüzü için varlığın işlevlerini bileşene yönlendirmeniz yeterlidir. Birazcık olsa olsa.

Fakat belki de en kolay olanı, bağlı bileşenleri geçerli bir özellik olup olmadığını araştırmak için Varlık sınıfınızdaki [] operatörüne aşırı yüklemek ve bunu döndürmek olabilir e["Name"] = "blah". Her bileşenin kendi GetPropertyByName uygulamasını kullanması gerekir ve Varlık söz konusu mülkten sorumlu bileşeni bulana kadar sırayla her birini çağırır.

Kylotan'ın cevabını genişletmek için, eğer C # 4.0 kullanıyorsanız, dinamik olarak bir değişkeni statik olarak yazabilirsiniz .

System.Dynamic.DynamicObject öğesinden devralırsanız, bileşen adlarını kesmek ve istenen bileşeni geri döndürmek için TryGetMember ve TrySetMember'i (birçok sanal yöntem arasında) geçersiz kılabilirsiniz.

dynamic entity = EntityRegistry.Entities[1000];
entity.MyComponent.MyValue = 100;

Yıllar boyunca varlık sistemleri hakkında biraz yazdım, ancak devlerle rekabet edemeyeceğimi farz ediyorum. Bazı ES notları (biraz modası geçmiş ve zorunlu olarak şu anki varlık sistemleri anlayışımı yansıtmıyor, ama okumaya değer.

C # ile ES burada çok ilgi görüyorum. Mükemmel ES uygulaması Artemis’in limanına göz atın:

https://github.com/thelinuxlich/artemis_CSharp

Ayrıca, nasıl çalıştığını anlamanız için örnek bir oyun (XNA 4 kullanarak): https://github.com/thelinuxlich/starwarrior_CSharp

Önerilerinizi bekliyoruz!

C # 'nın mükemmel yansıma sistemini kullanmaya karar verdim. Bunu genel bileşen sisteminden ve buradaki cevapların bir karışımından kurdum.

Bileşenler çok kolay bir şekilde eklenir:

Entity e = new Entity(); //No templates/archetypes yet.
e.AddComponent(new HealthComponent(100));

Ve özelliklerine göre adı, türü veya (eğer Sağlık ve Pozisyon gibi ortak olanları) sorgulanabilir:

e["Health"] //This, unfortunately, is a bit slower since it requires a dict search
e.GetComponent<HealthComponent>()
e.Health

Ve kaldırıldı:

e.RemoveComponent<HealthComponent>();

Verilere yine özelliklerle erişilir:

e.MaxHP

Hangi bileşen tarafında saklanır; HP yoksa daha az ek yük:

public int? MaxHP
{
get
{

    return this.Health.MaxHP; //Error handling returns null if health isn't here. Excluded for clarity
}
set
{
this.Health.MaxHP = value;
}

VS'deki Intellisense tarafından büyük miktarda yazmaya yardımcı oluyor, ancak çoğunlukla küçük yazım var - aradığım şey.

Perde arkasını saklıyorum Dictionary<Type, Component>ve isim kontrolü Componentsiçin kullanılan ToStringmetodu geçersiz kılıyorum. Özgün tasarımım öncelikle isimler ve şeyler için karakter dizileri kullandı, ancak çalışmak için bir domuz haline geldi (oh, bak, her yere döküm yapmam gerekiyor, aynı zamanda kolay erişilemeyen özellikler).