Feuilles de root

Logiciels libres, programmation et économie

Accueil » Programmation » Programmation Free Pascal » Les systèmes à entités

Les systèmes à entités

Introduction

Les systèmes à entités (entity systems) visent à répondre aux limites d'une approche orientée objets (basée sur des hiérarchies de classes). Dans un système à entités, au lieu de définir des classes et d'instancier des objets, on associe dynamiquement des composants (classes ou structures représentant les données) à des entités qui ne sont au final que des identifiants. On aboutit à une stricte séparation entre d'un côté des composants qui ne contiennent que des données et des systèmes qui définissent les traitements à effectuer.

Liens

Evolve Your Hierarchy : Refactoring Game Entities with Components

Entity Systems are the future of MMOG development – Part 1

Introduction to Component Based Architecture in Games

Passez à l’ Entity System ! Partie 1

Understanding Component-Entity-Systems

Un système à entités en Free Pascal

Voici une implémentation basique mais complète du système à entités décrit ici : RDBMS Beta

type

    { TIntegerList }

    TIntegerList = class(specialize TFPGList<Integer>)
        function Contains(const AValue : Integer) : Boolean;
    end;

    TComponentStore = specialize TDictionary<Integer, IComponent>;

    TComponentStores = specialize TDictionary<String, TComponentStore>;

    TComponentList = specialize TFPGList<IComponent>;

    { TEntityManager }

    TEntityManager = class
    private
        FLowestUnassignedEntityID : Integer;
        FCriticalSection : TCriticalSection;
    public
        { While frozen, an EntityManager ignores all calls to create, modify, or delete entities. }
        FFrozen : Boolean;
        { All entities in existence }
        FAllEntities : TIntegerList;
        { Component stores }
        FComponentStores : TComponentStores;
        function CreateEntity : Integer;
        function GetComponent(const AEntity : Integer; const AComponentType : String) : IComponent;
        function HasComponentOfType(const AEntity : Integer; const AComponentType : String) : Boolean;
        function GetAllComponentsOfType(AComponentType : String) : TComponentList;
        function GetAllEntitiesPossessingComponent(AComponentType : String) : TIntegerList;
        function GetAllComponentsOnEntity(const AEntity : Integer) : TComponentList;
        procedure AddComponent(const AEntity : Integer; AComponent : IComponent);
        procedure RemoveComponent(const AEntity : Integer; AComponent : IComponent);
        procedure KillEntity(const AEntity : Integer);
        procedure Freeze;
        procedure UnFreeze;
        constructor Create;
        function GenerateNewEntityID : Integer;
        destructor Destroy; override;
    end;

Cette implémentation utilise ma classe TDictionary, qui fournit en partie les mêmes fonctionnalités que la classe Delphi du même nom.

Code source