Entia 1.4.0

IRunEach

• added new systems interfaces for common iteration scenarios named IRunEach<T1... T7>
• iteration using this interface uses less memory than using a Group<T> since it does not require caching the query structs and iterates using the most performant iteration pattern
• query attributes can still be used with these interfaces by applying them on the implementation method Run

Families

• added a new Families module to facilitate the usage of hierarchical structures of entities in a performant manner
• added an AllFamilies injectable to interact with the Families module
• added tests for Families module
• fixed a few bugs where a family loop would be allowed in some cases in the Families module

Serialization

• added an experimental serialization solution that revolves around Buffer.MemoryCopy which gives it a huge performance boost compared to BinaryFormatter for blittable types (especially blittable arrays) which the framework strongly uses and encourages
• the solution is currently contained in the Entia.Experimental namespace since it is not yet production ready
• can be used through the world.Serialize(instance, out var bytes); world.Deserialize(bytes, out instance) extensions located in the Entia.Experimental.Serialization namespace
• new serializers can be defined by implementing the ISerializer interface or Serializer<T> abstract class and then linking the implementation through the world.Container

Container

• added a new and much more general mechanism for extensibility that is heavily inspired by "traits" which exist in some other programming languages
• data types are linked to some behavior using the IImplementation interface or the ImplementationAttribute attribute
• behaviors can be any interface that implements the empty ITrait interface
• implementations can be retrieved using a Container instance
• every World now comes with its own Container instance
• new implementations can be linked with data types through the Container instance
• new traits can be defined and will be immediately usable with a Container
• the framework now makes extensive use of the Container
• this allowed the removal of a few world modules which only contained boiler plate code for extensibility

Others

• added a few convenient system interfaces: IOnAdd<T>, IOnRemove<T>, IOnEnable<T> and IOnDisable<T> which give access to the T component
• improved performance of TypeMap and reduced locking
• added a convenient Get method on Group<T> and its injectables
• Components.TryGet<T> now allows for an abstract T type
• better Entity debug view
• ensured that no static reference to a world is kept withing the framework because it would prevent it from being GC'ed
• added more extensions for Option<T> and Result<T>
• the ISilent<T> interface is more type-safe

Entia 1.3.0

Features

• added support for pointers in query structs for blittable components
  
  • note that stores that have a pointer taken from them will be pinned in memory
  • note that taking a pointer to a non-blittable type will cause an exception to be thrown
• World.Clear now clears all its modules before removing them
• Modules.Controllers is now more complete
• Group is specially optimized to remove redundant caching of entities
• Receiver<T> now has a Pop that returns an enumerable that pops as many messages as it is enumerated
• better UnsafeUtility layout detection
• Modules.resources is now thread safe
• reduced locking in Components operations when possible
• reduced contention when emitting messages
• added more Components.Has overloads
• more LinqExtensions
• added Box<T>
• added a Visitor class to modify a Node structure

Fixes

• fixed some generic constraints in component Injectables
• fixed a null exception in Components.Clear
• added missing Components methods in their corresponding Injectables
• more consistent Group<T>.TryGet behavior

*skipped 1.2.0 to align version with Entia.Unity

Entia 1.1.1

• Added a States field in Read<T>/Write<T> queries to retrieve the state of their component
• Added some ItemExtensions to facilitate unwrapping a component and its state

Entia 1.1.0

Features

• components can now be enabled and disabled via the Enable/Disable methods
• the state of components can be retrieved via the State methods
• components can always be enabled if they derive from the new IEnabled component interface
• OnEnable<T>/OnDisable<T> messages are now emitted when a component is enabled/disabled
• by default, groups will exclude disabled components, but they can be included by using the new [Include] attribute which will override the inclusion filter
• the [Include] attribute can be used on query types, on query fields or on group fields
• added the ISilent and ISilent<T> component interfaces to allow components the inherit from them to not emit component messages such as OnAdd<T>/OnRemove<T>
• added AllResources and AllResources.Read injectables
• added Defer.Entities and Defer.Components injectables
• added a few ItemExtensions
• support for abstract type parameters in more places

Improvements

• existing [All][Any][None][Query] query attributes can now specify an inclusion filter for their query
• added an inclusion filter parameters everywhere possible in the Components module and injectables methods
• reduced memory usage of cached TypeData
• empty components don't reserve stores anymore
• empty components are not uselessly copied when an entity is moved
• improved thread safety
• removed the PlainAttribute
• added a plenty of tests
• can no longer remove a component as part of a OnAdd or OnRemove reaction

Fixes

• fixed a bug where a default instance provided by DefaultUtility could be mutated
• fixed a bug where private properties would not work as default providers
• fixed a bug where some OnRemove<T> messages would not be emitted when using Clear
• fixed a bug where some messages could accidentally be emitted recursively if a reaction caused the message to be emitted
• fixed a bug where query attributes would be checked twice when building a query

Entia 1.0.5

• allowed to inspect the components of an Entity in a debugger (issue #15)
• added a special component Entia.Components.Debug which is used to display a debug name for an Entity
• added a special resource Entia.Resources.Debug which is used to display a debug name for a World
• fixed memory allocation when using the TryFirst() (issue #14)
• merged the Entia.Modules.Cloners module in module Entia.Modules.Components
• fixed some inconsistencies in TypeMap
• fixed a BitMask bug that would occur when using more than 64 component types

Entia 1.0.4

• New Modules.Cloners module to allow efficient and extensible cloning of components.
• [Plain] attribute that allows to define a component as plain old data. This is useful in cases where a component to be cloned is not obviously plain (containing only primitive types or structs of primitive types) and still should be cloned as if it were plain.
• [Default] attribute that allows to define a field/property/method that provides a default instance of a component/resource/message/phase/system.
• Overloads that make use of default providers for modules and injectables.
• Controller is more thread-safe
• Added versions to assemblies.
• Reduced contention when emitting messages from the Modules.Messages module.

Entia 1.0.3

• more AOT friendly
• more thread-safety

Entia 1.0.2

• fixed issues related with IL2CPP builds
• separated node building from specializing
• components are cleared if they hold managed references

Entia 1.0.1

• fixed: IReact.React() would sometimes be called more than once for 1 message emission
• made the framework more AOT friendly
• fixed a memory alignment issue that would occur when building with IL2CPP and Unity

Entia 1.0.0

Initial release.