Tổ chức một hệ thống thực thể với các nhà quản lý thành phần bên ngoài?

Tôi đang thiết kế một công cụ trò chơi cho một trò chơi bắn súng 2D nhiều người chơi từ trên xuống, mà tôi muốn có thể sử dụng lại một cách hợp lý cho các trò chơi bắn súng từ trên xuống khác. Hiện tại tôi đang suy nghĩ về cách một cái gì đó giống như một hệ thống thực thể trong nó nên được thiết kế. Đầu tiên tôi nghĩ về điều này:

Tôi có một lớp gọi là EntityManager. Nó nên thực hiện một phương thức gọi là Cập nhật và một phương thức khác gọi là Draw. Lý do để tôi tách Logic và Kết xuất là vì sau đó tôi có thể bỏ qua phương thức Draw nếu chạy một máy chủ độc lập.

EntityManager sở hữu một danh sách các đối tượng thuộc loại BaseEntity. Mỗi thực thể sở hữu một danh sách các thành phần như EntityModel (đại diện có thể rút ra của một thực thể), EntityNetworkInterface và EntityPhysicalBody.

EntityManager cũng sở hữu một danh sách các trình quản lý thành phần như EntityRenderManager, EntityNetworkManager và EntityPhysicsManager. Mỗi trình quản lý thành phần giữ các tham chiếu đến các thành phần thực thể. Có nhiều lý do khác nhau để di chuyển mã này ra khỏi lớp riêng của thực thể và thay vào đó thực hiện mã này. Ví dụ: tôi đang sử dụng thư viện vật lý bên ngoài, Box2D, cho trò chơi. Trong Box2D, trước tiên bạn thêm các cơ thể và hình dạng vào một thế giới (thuộc sở hữu của EntityPhysicsManager trong trường hợp này) và thêm các cuộc gọi lại va chạm (sẽ được gửi đến chính đối tượng thực thể trong hệ thống của tôi). Sau đó, bạn chạy một chức năng mô phỏng mọi thứ trong hệ thống. Tôi thấy thật khó để tìm một giải pháp tốt hơn để làm điều này hơn là làm nó trong một trình quản lý thành phần bên ngoài như thế này.

Việc tạo thực thể được thực hiện như thế này: EntityManager thực hiện phương thức RegisterEntity (entityClass, nhà máy) để đăng ký cách tạo một thực thể của lớp đó. Nó cũng thực hiện phương thức CreateEntity (entityClass) sẽ trả về một đối tượng kiểu BaseEntity.

Bây giờ đến vấn đề của tôi: Làm thế nào tham chiếu đến một thành phần được đăng ký cho các nhà quản lý thành phần? Tôi không biết làm thế nào tôi sẽ tham khảo các nhà quản lý thành phần từ một nhà máy / đóng cửa.

Các hệ thống nên lưu trữ một cặp giá trị chính của Thực thể cho Thành phần trong một số loại Bản đồ, Đối tượng từ điển hoặc Mảng liên kết (tùy thuộc vào ngôn ngữ được sử dụng). Hơn nữa, khi bạn tạo Đối tượng Thực thể, tôi sẽ không lo lắng về việc lưu trữ nó trong trình quản lý trừ khi bạn cần có thể hủy đăng ký nó khỏi bất kỳ Hệ thống nào. Một thực thể là một tổng hợp của các thành phần, nhưng nó không nên xử lý bất kỳ cập nhật thành phần nào. Điều đó nên được xử lý bởi các hệ thống. Thay vào đó, hãy coi Thực thể của bạn như một khóa được ánh xạ tới tất cả các thành phần có trong hệ thống, cũng như một trung tâm liên lạc để các thành phần đó nói chuyện với nhau.

Phần lớn về các mô hình Entity-Element-System là bạn có thể thực hiện khả năng truyền thông điệp từ một thành phần này đến các thành phần còn lại của một thực thể khá dễ dàng. Điều này cho phép một thành phần nói chuyện với thành phần khác mà không thực sự biết thành phần đó là ai hoặc cách xử lý thành phần mà nó đang thay đổi. Thay vào đó, nó chuyển một thông điệp và cho phép thành phần tự thay đổi (nếu nó tồn tại)

Chẳng hạn, Hệ thống Vị trí sẽ không có nhiều mã trong đó, chỉ theo dõi các Đối tượng Thực thể được ánh xạ tới Thành phần Vị trí của chúng. Nhưng khi một vị trí thay đổi, họ có thể gửi tin nhắn đến Thực thể có liên quan, đến lượt nó được gửi đến tất cả các thành phần của thực thể đó. Một vị trí thay đổi cho lý do bao giờ? Hệ thống vị trí gửi cho Thực thể một thông báo nói rằng vị trí đã thay đổi và ở đâu đó, thành phần kết xuất hình ảnh của thực thể đó nhận được thông báo đó và cập nhật nơi nó sẽ tự vẽ tiếp theo.

Ngược lại, Hệ thống Vật lý cần biết tất cả các đối tượng của nó đang làm gì; Nó phải có khả năng nhìn thấy tất cả các vật thể trên thế giới để kiểm tra va chạm. Khi xảy ra xung đột, nó cập nhật thành phần chỉ đường của Thực thể bằng cách gửi một số loại "Thông báo thay đổi hướng" đến thực thể thay vì tham khảo trực tiếp thành phần của Thực thể. Điều này ngăn cản người quản lý cần biết cách thay đổi hướng bằng cách sử dụng tin nhắn thay vì dựa vào một thành phần cụ thể ở đó (trong đó có thể không có ở đó, trong trường hợp đó, tin nhắn sẽ rơi vào tai người điếc thay vì một số lỗi xảy ra vì một đối tượng dự kiến ​​vắng mặt).

Bạn sẽ nhận thấy một lợi thế rất lớn từ việc này vì bạn đã đề cập rằng bạn có Giao diện Mạng. Một Thành phần Mạng sẽ lắng nghe tất cả các tin nhắn đến mà mọi người khác nên biết. Nó thích những tin đồn. Sau đó, khi Hệ thống mạng cập nhật, các thành phần Mạng gửi các tin nhắn đó đến các Hệ thống mạng khác trên các máy khách khác, sau đó gửi lại các tin nhắn đó đến tất cả các thành phần khác để cập nhật vị trí trình phát, v.v. gửi tin nhắn qua mạng nhưng đó là vẻ đẹp của Hệ thống, bạn có thể kiểm soát logic đó bằng cách đăng ký những thứ phù hợp với nó.

Nói ngắn gọn:

Thực thể là một thành phần của các thành phần có thể nhận tin nhắn. Thực thể có thể nhận tin nhắn, ủy quyền tin nhắn cho tất cả các thành phần của chúng để cập nhật chúng. (Vị trí đã thay đổi Tin nhắn, Hướng thay đổi tốc độ, v.v.) Nó giống như một hộp thư trung tâm mà tất cả các thành phần có thể nghe thấy nhau thay vì nói chuyện trực tiếp với nhau.

Thành phần là một phần nhỏ của Thực thể lưu trữ một số trạng thái của thực thể. Đây có thể phân tích một số tin nhắn nhất định và ném các tin nhắn khác ra. Chẳng hạn, "Thành phần chỉ đường" sẽ chỉ quan tâm đến "Thông báo thay đổi hướng" chứ không phải "Thông báo thay đổi vị trí". Các thành phần cập nhật trạng thái của riêng chúng dựa trên tin nhắn và sau đó cập nhật trạng thái của các thành phần khác bằng cách gửi tin nhắn từ Hệ thống của chúng.

Hệ thống quản lý tất cả các thành phần của một loại nhất định và chịu trách nhiệm cập nhật các thành phần nói trên từng khung, cũng như gửi tin nhắn từ thành phần mà chúng quản lý đến các Thực thể mà Thành phần thuộc về

Các hệ thống có thể có thể cập nhật song song tất cả các thành phần của chúng và lưu trữ tất cả các tin nhắn khi chúng đi. Sau đó, khi thực hiện tất cả các phương thức cập nhật của Hệ thống hoàn tất, bạn yêu cầu mỗi hệ thống gửi tin nhắn của chúng theo một thứ tự cụ thể. Điều khiển trước tiên có thể, tiếp theo là Vật lý, tiếp theo là hướng, vị trí, kết xuất, v.v ... Vấn đề là chúng được gửi theo thứ tự nào vì Thay đổi hướng Vật lý phải luôn luôn cân nhắc thay đổi hướng điều khiển.

Hi vọng điêu nay co ich. Đó là một địa ngục của Mẫu thiết kế, nhưng nó cực kỳ mạnh mẽ nếu được thực hiện đúng.

Tôi đang sử dụng một hệ thống tương tự trong công cụ của mình và cách tôi thực hiện là mỗi Thực thể chứa một danh sách Thành phần. Từ EntityManager, tôi có thể truy vấn từng Thực thể và xem những thực thể nào chứa Thành phần nhất định. Thí dụ:

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;
    }
}

Rõ ràng đây không phải là mã chính xác (bạn thực sự cần một hàm mẫu để kiểm tra các loại thành phần khác nhau, thay vì sử dụng typeof) nhưng khái niệm là có. Sau đó, bạn có thể lấy các kết quả đó, tham khảo thành phần bạn đang tìm kiếm và đăng ký nó với nhà máy của bạn. Điều này ngăn chặn bất kỳ khớp nối trực tiếp giữa các thành phần và người quản lý của họ.

1) Phương thức Factory của bạn phải được chuyển tham chiếu đến EntityManager đã gọi nó (Tôi sẽ sử dụng C # làm ví dụ):

delegate BaseEntity EntityFactory(EntityManager manager);

2) Have CreatEntity cũng nhận được một id (ví dụ: chuỗi, số nguyên, tùy thuộc vào bạn) bên cạnh lớp / loại thực thể và tự động đăng ký thực thể được tạo trên Từ điển bằng cách sử dụng id đó làm khóa:

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) Thêm Getter vào EntityManager để nhận bất kỳ thực thể nào bằng ID:

class EntityManager
{
    // Rest of class omitted

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

Và đó là tất cả những gì bạn cần để tham khảo bất kỳ Trình quản lý thành phần nào trong phương thức Factory của bạn. Ví dụ:

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;
}

Ngoài Id, bạn cũng có thể sử dụng một số loại thuộc tính Loại (enum tùy chỉnh hoặc chỉ dựa vào hệ thống loại ngôn ngữ) và tạo một getter trả về tất cả BaseEntities của một loại nhất định.