Harici bileşen yöneticileriyle bir varlık sistemi mi düzenliyorsunuz?

Yukarıdan aşağıya çok oyunculu bir 2D shooter oyunu için bir oyun motoru tasarlıyorum, diğer yukarıdan aşağıya atıcı oyunlar için makul şekilde tekrar kullanılabilir olmak istiyorum. Şu anda içinde bir varlık sistemi gibi bir şeyin nasıl tasarlanması gerektiğini düşünüyorum. Önce şunu düşündüm:

EntityManager adlı bir sınıfım var. Update adlı bir yöntem ve Draw adlı başka bir yöntem uygulamalıdır. Mantık ve İşleme'yi ayırmamın nedeni, bağımsız bir sunucu çalıştırıyorsanız Draw yöntemini atlayabilmemdir.

EntityManager, BaseEntity türünde nesnelerin bir listesine sahiptir. Her varlığın EntityModel (bir varlığın çekilebilir temsili), EntityNetworkInterface ve EntityPhysicalBody gibi bileşenlerin bir listesi vardır.

EntityManager ayrıca EntityRenderManager, EntityNetworkManager ve EntityPhysicsManager gibi bileşen yöneticilerinin bir listesine sahiptir. Her bileşen yöneticisi varlık bileşenlerine başvuruları tutar. Bu kodu kurumun kendi sınıfının dışına taşımak ve toplu olarak yapmak için çeşitli nedenler vardır. Örneğin, oyun için harici bir fizik kütüphanesi olan Box2D kullanıyorum. Box2D'de, önce gövdeleri ve şekilleri bir dünyaya (bu durumda EntityPhysicsManager'a ait olan) ekler ve çarpışma geri çağrılarını (sistemimdeki varlık nesnesinin kendisine gönderilir) eklersiniz. Daha sonra sistemdeki her şeyi simüle eden bir işlev çalıştırırsınız. Bunu yapmak için böyle bir harici bileşen yöneticisinde yapmaktan daha iyi bir çözüm bulmakta zorlanıyorum.

Varlık oluşturma şu şekilde yapılır: EntityManager bu sınıfın bir varlığının nasıl oluşturulacağını kaydeden RegisterEntity (entityClass, factory) yöntemini uygular . Ayrıca BaseEntity türünde bir nesne döndürecek CreateEntity (entityClass) yöntemini uygular.

Şimdi sorunum geliyor: Bir bileşene yapılan başvuru, bileşen yöneticilerine nasıl kaydedilir? Bir fabrikadan / kapanıştan bileşen yöneticilerine nasıl başvuracağım konusunda hiçbir fikrim yok.

Sistemler, bir Bileşen Varlığı için anahtar / değer çiftini bir tür Harita, Sözlük Nesnesi veya İlişkilendirilebilir Dizi içinde (kullanılan dile bağlı olarak) saklamalıdır. Dahası, Varlık Nesnenizi oluşturduğunuzda, herhangi bir Sistemin kaydını silmeniz gerekmedikçe bir yöneticide saklamaktan endişe etmem. Varlık, bileşenlerin bir bileşimidir, ancak bileşen güncellemelerinin hiçbirini işlememelidir. Bunun Sistemler tarafından ele alınması gerekir. Bunun yerine, Varlığınızı sistemlerde içerdiği tüm bileşenlerle eşlenen bir anahtar ve bu bileşenlerin birbirleriyle konuşması için bir iletişim merkezi olarak ele alın.

Entity-Component-System modellerinin en önemli yanı, mesajları bir bileşenden bir varlığın bileşenlerinin geri kalanına kolayca iletebilmenizdir. Bu, bir bileşenin gerçekte kim olduğunu veya değiştirdiği bileşeni nasıl işleyeceğini bilmeden başka bir bileşenle konuşmasına olanak tanır. Bunun yerine bir ileti iletir ve bileşenin kendisini değiştirmesine izin verir (varsa)

Örneğin, bir Konum Sistemi içinde çok fazla kod bulunmayacak ve yalnızca Konum Bileşenleri ile eşlenmiş Varlık Nesnelerinin izini sürecektir. Ancak bir pozisyon değiştiğinde, ilgili Varlığa bir mesaj gönderebilir ve bu mesaj da o varlığın tüm bileşenlerine dağıtılır. Her ne sebeple bir pozisyon değişir? Konum Sistemi, Varlığa konumun değiştiğini söyleyen bir mesaj gönderir ve bir yerde o varlığın görüntü oluşturma bileşeni bu mesajı alır ve bir sonraki çizeceği yeri günceller.

Tersine, bir Fizik Sisteminin tüm nesnelerinin ne yaptığını bilmesi gerekir; Çarpışmaları test etmek için tüm dünya nesnelerini görebilmelidir. Bir çarpışma meydana geldiğinde, doğrudan Varlığın bileşenine başvurmak yerine bir tür "Yön Değişiklik Mesajı" göndererek Varlığın yön bileşenini günceller. Bu, yöneticinin, orada bulunan belirli bir bileşene güvenmek yerine bir mesaj kullanarak yönleri nasıl değiştireceğini bilmesine ihtiyaç duymasını engeller (bu hiç olmayabilir), bu durumda mesaj sadece bir hata yerine sağır kulaklara düşer çünkü beklenen bir nesne yoktu).

Bir Ağ Arayüzünüz olduğundan bahsettiğiniz için bundan büyük bir avantaj göreceksiniz. Bir Ağ Bileşeni, herkesin bilmesi gereken tüm mesajları dinler. Dedikoduyu çok seviyor. Daha sonra Ağ Sistemi güncellendiğinde, Ağ bileşenleri bu mesajları diğer istemci makinelerde diğer Ağ Sistemlerine gönderir, bu da oyuncu konumlarını güncellemek için bu mesajları diğer tüm bileşenlere tekrar gönderir. Yalnızca belirli varlıkların ağ üzerinden mesaj gönderin ancak Sistemin güzelliği budur, sadece doğru mantığı ona kaydederek bu mantığı kontrol etmesini sağlayabilirsiniz.

Kısacası:

Varlık, mesaj alabilen Bileşenlerin bir bileşimidir. Varlık mesaj alabilir, söz konusu mesajları güncellemek için tüm bileşenlerine devredebilir. (Konum değişti Mesaj, Hız Değiştirme Yönü, vb.) Tüm bileşenlerin doğrudan birbirleriyle konuşmak yerine birbirlerinden duyabileceği merkezi bir posta kutusu gibidir.

Bileşen, bir varlığın bir kısmını saklayan bir Varlığın küçük bir parçasıdır. Bunlar belirli mesajları ayrıştırabilir ve diğer mesajları dışarı atabilir. Örneğin, bir "Yön Bileşeni" yalnızca "Yön Değişikliği Mesajları" nı dikkate alır, ancak "Konum Değişikliği Mesajları" nı önemsemez. Bileşenler iletileri temel alarak kendi durumlarını güncelleştirir ve ardından Sistemlerinden ileti göndererek diğer bileşenlerin durumlarını güncelleştirir.

Sistem belirli bir türdeki tüm bileşenleri yönetir ve adı geçen bileşenleri her bir karenin güncellemesinden ve yönettikleri bileşenin Bileşenlerin ait olduğu Varlıklara mesaj göndermekten sorumludur

Sistemler tüm bileşenlerini paralel olarak güncelleyebilir ve tüm mesajları giderken depolayabilir. Ardından, tüm Sistemlerin güncelleme yöntemlerinin yürütülmesi tamamlandığında, her sistemden mesajlarını belirli bir sırada göndermesini istersiniz. Muhtemelen önce kontroller, ardından Fizik, ardından yön, konum, görüntü oluşturma, vb. Gönderilir. Fizik Yönü Değişimi Daima dışarıya bağlı olarak kontrol tabanlı bir yön değişikliğini tartmalıdır.

Bu yardımcı olur umarım. Bu bir Tasarım Deseni cehennemi, ama doğru yapılırsa gülünç derecede güçlü.

Motorumda benzer bir sistem kullanıyorum ve bunu yaptığım şekilde, her Varlık bir Bileşenler listesi içeriyor. EntityManager'dan, Varlıkların her birini sorgulayabilir ve hangilerinin belirli bir Bileşen içerdiğini görebilirim. Misal:

class Component
{
    private uint ID;
    // etc...
}

class Entity
{
    List<Component> Components;
    // etc...
    public bool Contains(Type type)
    {
        foreach(Component comp in Components)
        {
            if(typeof(comp) == type)
                return true;
        }
        return false;
    }
}

class EntityManager
{
    List<Entity> Entities;
    // etc...
    public List<Entity> GetEntitiesOfType(Type type)
    {
        List<Entity> results = new List<Entity>();
        foreach(Entity entity in Entities)
        {
            if(entity.Contains(type))
                results.Add(entity);
        }
        return results;
    }
}

Açıkçası bu tam kod değil (aslında kullanmak yerine farklı bileşen türlerini kontrol etmek için bir şablon fonksiyonuna ihtiyacınız olacak typeof) ama konsept var. Ardından bu sonuçları alabilir, aradığınız bileşene başvurabilir ve fabrikanıza kaydedebilirsiniz. Bu, Bileşenler ve yöneticileri arasındaki doğrudan bağlantıyı önler.

1) Fabrika yönteminiz, EntityManager'a çağrı yapan bir referans geçirilmelidir (örnek olarak C # kullanacağım):

delegate BaseEntity EntityFactory(EntityManager manager);

2) Ayrıca, CreateEntity öğesinin sınıfının / türünün yanı sıra bir kimlik (ör. Bir dize, tamsayı, size kalmış) almasını ve oluşturulan kimliği otomatik olarak bu kimliği anahtar olarak kullanarak bir Sözlüğe kaydettirmesini sağlar:

class EntityManager
{
    // Rest of class omitted

    BaseEntity CreateEntity(string id, Type entityClass)
    {
        BaseEntity entity = factories[entityClass](this);
        registry.Add(id, entity);
        return entity;
    }

    Dictionary<Id, BaseEntity> registry;
}

3) Herhangi bir varlığı kimliğe göre almak için EntityManager'a bir Alıcı ekleyin:

class EntityManager
{
    // Rest of class omitted

    BaseEntity GetEntity(string id)
    {
        return registry[id];
    }
}

Fabrika yönteminizden herhangi bir ComponentManager'a başvurmak için ihtiyacınız olan tek şey budur. Örneğin:

BaseEntity CreateSomeSortOfEntity(EntityManager manager)
{
    // Create and configure entity
    BaseEntity entity = new BaseEntity();
    RenderComponent renderComponent = new RenderComponent();
    entity.AddComponent(renderComponent);

    // Get a reference to the render manager and register component
    RenderEntityManager renderer = manager.GetEntity("RenderEntityManager") as RenderEntityManager;
    if(renderer != null)
        renderer.Register(renderComponent)

    return entity;
}

Id'in yanı sıra bir tür Type özelliği de kullanabilirsiniz (özel bir numaralandırma veya dilin tür sistemine güvenebilirsiniz) ve belirli bir türdeki tüm BaseEntities'i döndüren bir alıcı oluşturabilirsiniz.