Syntriax/Syntriax.Engine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor!: renamed GameManager to Universe and HierarchyObject to UniverseObject

Browse Source
This commit is contained in:
Syntriax 2025-04-13 21:57:05 +03:00
parent a9f5974568
commit 70c884acfe
46 changed files with 749 additions and 750 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
Engine.Core/Abstract/Assignable/IHasGameManager.cs
View File

@ -1,26 +0,0 @@
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="ITransform2D"/> field.
/// </summary>
public interface IHasGameManager : IAssignable
{
/// <summary>
/// Event triggered when the <see cref="IGameManager"/> value has has been assigned a new value.
/// </summary>
event GameManagerAssignedEventHandler? OnGameManagerAssigned;
/// <inheritdoc cref="IGameManager" />
IGameManager GameManager { get; }
/// <summary>
/// Assign a value to the <see cref="IGameManager"/> field of this object.
/// </summary>
/// <param name="gameManager">New <see cref="IGameManager"/> to assign.</param>
/// <returns>
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(IGameManager gameManager);
delegate void GameManagerAssignedEventHandler(IHasGameManager sender);
}

26
Engine.Core/Abstract/Assignable/IHasHierarchyObject.cs
View File

@ -1,26 +0,0 @@
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="IHierarchyObject"/> field.
/// </summary>
public interface IHasHierarchyObject : IAssignable
{
/// <summary>
/// Event triggered when the <see cref="IHierarchyObject"/> value has has been assigned a new value.
/// </summary>
event HierarchyObjectAssignedEventHandler? OnHierarchyObjectAssigned;
/// <inheritdoc cref="IHierarchyObject" />
IHierarchyObject HierarchyObject { get; }
/// <summary>
/// Assign a value to the <see cref="IHierarchyObject"/> field of this object.
/// </summary>
/// <param name="hierarchyObject">New <see cref="IHierarchyObject"/> to assign.</param>
/// <returns>
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(IHierarchyObject hierarchyObject);
delegate void HierarchyObjectAssignedEventHandler(IHasHierarchyObject sender);
}

26
Engine.Core/Abstract/Assignable/IHasUniverse.cs Normal file
View File

@ -0,0 +1,26 @@
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="IUniverse"/> field.
/// </summary>
public interface IHasUniverse : IAssignable
{
/// <summary>
/// Event triggered when the <see cref="IUniverse"/> value has has been assigned a new value.
/// </summary>
event UniverseAssignedEventHandler? OnUniverseAssigned;
/// <inheritdoc cref="IUniverse" />
IUniverse Universe { get; }
/// <summary>
/// Assign a value to the <see cref="IUniverse"/> field of this object.
/// </summary>
/// <param name="universe">New <see cref="IUniverse"/> to assign.</param>
/// <returns>
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(IUniverse universe);
delegate void UniverseAssignedEventHandler(IHasUniverse sender);
}

26
Engine.Core/Abstract/Assignable/IHasUniverseObject.cs Normal file
View File

@ -0,0 +1,26 @@
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Indicates the object is an <see cref="IAssignable"/> with an assignable <see cref="IUniverseObject"/> field.
/// </summary>
public interface IHasUniverseObject : IAssignable
{
/// <summary>
/// Event triggered when the <see cref="IUniverseObject"/> value has has been assigned a new value.
/// </summary>
event UniverseObjectAssignedEventHandler? OnUniverseObjectAssigned;
/// <inheritdoc cref="IUniverseObject" />
IUniverseObject UniverseObject { get; }
/// <summary>
/// Assign a value to the <see cref="IUniverseObject"/> field of this object.
/// </summary>
/// <param name="universeObject">New <see cref="IUniverseObject"/> to assign.</param>
/// <returns>
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(IUniverseObject universeObject);
delegate void UniverseObjectAssignedEventHandler(IHasUniverseObject sender);
}

2
Engine.Core/Abstract/IBehaviour.cs
View File

@ -1,7 +1,7 @@
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents a behaviour that any object in the game might use to interact with itself or other objects.
/// Represents a behaviour that any object in the engine that might use to interact with itself or other objects.
/// </summary>
public interface IBehaviour : IEntity, IActive, IHasBehaviourController, IHasStateEnable
{

4
Engine.Core/Abstract/IBehaviourCollector.cs
View File

@ -4,10 +4,10 @@ namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents a collector for the class type of <typeparamref name="T"/>.
/// Provides mechanisms for tracking additions and removals, and notifies subscribers when such events occur on the assigned <see cref="IGameManager"/>.
/// Provides mechanisms for tracking additions and removals, and notifies subscribers when such events occur on the assigned <see cref="IUniverse"/>.
/// </summary>
/// <typeparam name="T">The type of objects tracked by the collector.</typeparam>
public interface IBehaviourCollector<T> : IHasGameManager, IEnumerable<T> where T : class
public interface IBehaviourCollector<T> : IHasUniverse, IEnumerable<T> where T : class
{
/// <summary>
/// Event triggered when an object of type <typeparamref name="T"/> is added to the collector.

4
Engine.Core/Abstract/IBehaviourController.cs
View File

@ -3,9 +3,9 @@ using System.Collections.Generic;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents a controller for managing <see cref="IBehaviour"/>s and notify them accordingly about the engine's updates. Connected to an <see cref="IHierarchyObject"/>.
/// Represents a controller for managing <see cref="IBehaviour"/>s and notify them accordingly about the engine's updates. Connected to an <see cref="IUniverseObject"/>.
/// </summary>
public interface IBehaviourController : IInitializable, IHasHierarchyObject, IEnumerable<IBehaviour>
public interface IBehaviourController : IInitializable, IHasUniverseObject, IEnumerable<IBehaviour>
{
/// <summary>
/// Event triggered before the update of <see cref="IBehaviour"/>s.

91
Engine.Core/Abstract/IGameManager.cs
View File

@ -1,91 +0,0 @@
using System.Collections.Generic;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents a game world responsible for managing <see cref="IHierarchyObject"/>s.
/// </summary>
public interface IGameManager : IEntity, IEnumerable<IHierarchyObject>
{
/// <summary>
/// Event triggered when <see cref="Update(EngineTime)"/> is about to be called called on the <see cref="IGameManager"/>.
/// </summary>
event UpdateEventHandler? OnPreUpdate;
/// <summary>
/// Event triggered when <see cref="Update(EngineTime)"/> is called on the <see cref="IGameManager"/>.
/// </summary>
event UpdateEventHandler? OnUpdate;
/// <summary>
/// Event triggered when <see cref="PreDraw"/> is called on the <see cref="IGameManager"/>.
/// </summary>
event PreDrawEventHandler? OnPreDraw;
/// <summary>
/// Event triggered when a <see cref="IHierarchyObject"/> is registered to the <see cref="IGameManager"/>.
/// </summary>
event HierarchyObjectRegisteredEventHandler? OnHierarchyObjectRegistered;
/// <summary>
/// Event triggered when a <see cref="IHierarchyObject"/> is unregistered from the <see cref="IGameManager"/>.
/// </summary>
event HierarchyObjectUnRegisteredEventHandler? OnHierarchyObjectUnRegistered;
/// <summary>
/// Current time scale the <see cref="IGameManager"/> operates on.
/// </summary>
float TimeScale { get; set; }
/// <summary>
/// Contains time data related to this <see cref="IGameManager"/>.
/// </summary>
EngineTime Time { get; }
/// <summary>
/// Contains unscaled time data related to this <see cref="IGameManager"/>.
/// </summary>
EngineTime UnscaledTime { get; }
/// <summary>
/// Gets a read-only list of <see cref="IHierarchyObject"/>s managed by the <see cref="IGameManager"/>.
/// </summary>
IReadOnlyList<IHierarchyObject> HierarchyObjects { get; }
/// <summary>
/// Registers an <see cref="IHierarchyObject"/> to the <see cref="IGameManager"/>.
/// </summary>
/// <param name="hierarchyObject">The <see cref="IHierarchyObject"/> to register.</param>
void Register(IHierarchyObject hierarchyObject);
/// <summary>
/// Instantiates a <see cref="IHierarchyObject"/> of type T with the given arguments and registers it to the <see cref="IGameManager"/>.
/// </summary>
/// <typeparam name="T">The type of <see cref="IHierarchyObject"/> to instantiate.</typeparam>
/// <param name="args">Constructor parameters for the given type of <see cref="IHierarchyObject"/>.</param>
/// <returns>The instantiated <see cref="IHierarchyObject"/>.</returns>
T InstantiateHierarchyObject<T>(params object?[]? args) where T : class, IHierarchyObject;
/// <summary>
/// Removes an <see cref="IHierarchyObject"/> from the <see cref="IGameManager"/>.
/// </summary>
/// <param name="hierarchyObject">The <see cref="IHierarchyObject"/> to remove.</param>
void Remove(IHierarchyObject hierarchyObject);
/// <summary>
/// Updates the <see cref="IGameManager"/> with the given delta time.
/// </summary>
/// <param name="engineTime">Delta time.</param>
void Update(EngineTime engineTime);
/// <summary>
/// Performs operations that should be done before the draw calls.
/// </summary>
void PreDraw();
delegate void UpdateEventHandler(IGameManager sender, EngineTime engineTime);
delegate void PreDrawEventHandler(IGameManager sender);
delegate void HierarchyObjectRegisteredEventHandler(IGameManager sender, IHierarchyObject hierarchyObjectRegistered);
delegate void HierarchyObjectUnRegisteredEventHandler(IGameManager sender, IHierarchyObject hierarchyObjectUnregistered);
}

131
Engine.Core/Abstract/IHierarchyObject.cs
View File

@ -1,131 +0,0 @@
using System.Collections.Generic;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents an <see cref="IEntity"/> that can enter and exit a hierarchy within the <see cref="IGameManager"/> system.
/// This interface allows for tracking the object's presence in the hierarchy and provides events
/// for notifying when the see enters or exits the hierarchy.
/// </summary>
public interface IHierarchyObject : IEntity, IActive, INameable, IHasBehaviourController, IEnumerable<IHierarchyObject>
{
/// <summary>
/// Event triggered when the <see cref="IHierarchyObject"/> enters the hierarchy.
/// </summary>
event EnteredHierarchyEventHandler? OnEnteredHierarchy;
/// <summary>
/// Event triggered when the <see cref="IHierarchyObject"/> exits the hierarchy.
/// </summary>
event ExitedHierarchyEventHandler? OnExitedHierarchy;
/// <summary>
/// Event triggered when the <see cref="Parent"/> of the <see cref="IHierarchyObject"/> changes. The second parameter is the old <see cref="IHierarchyObject"/>.
/// </summary>
event ParentChangedEventHandler? OnParentChanged;
/// <summary>
/// Event triggered when a new <see cref="IHierarchyObject"/> is added to the <see cref="Children"/>.
/// </summary>
event ChildrenAddedEventHandler? OnChildrenAdded;
/// <summary>
/// Event triggered when an <see cref="IHierarchyObject"/> is removed from the <see cref="Children"/>.
/// </summary>
event ChildrenRemovedEventHandler? OnChildrenRemoved;
/// <summary>
/// Gets the <see cref="IGameManager"/> this <see cref="IHierarchyObject"/> is connected to, if any.
/// </summary>
IGameManager GameManager { get; }
/// <summary>
/// Indicates whether the <see cref="IHierarchyObject"/> is currently in the hierarchy.
/// </summary>
bool IsInHierarchy { get; }
/// <summary>
/// The parent <see cref="IHierarchyObject"/> of the <see cref="IHierarchyObject"/>.
/// </summary>
IHierarchyObject? Parent { get; }
/// <summary>
/// The <see cref="IHierarchyObject"/>s that have this <see cref="IHierarchyObject"/> as their <see cref="Parent"/>.
/// </summary>
IReadOnlyList<IHierarchyObject> Children { get; }
/// <summary>
/// Internal method to handle entering the hierarchy.
/// This should be called by the system to properly manage hierarchy states.
/// </summary>
/// <param name="gameManager">The <see cref="IGameManager"/> that is managing this hierarchy.</param>
/// <returns>
/// <see cref="true"/> if the <see cref="IHierarchyObject"/> successfully entered the hierarchy;
/// <see cref="false"/> if it failed to do so.
/// </returns>
internal bool EnterHierarchy(IGameManager gameManager);
/// <summary>
/// Internal method to handle exiting the hierarchy.
/// This should be called by the system to properly manage hierarchy states.
/// </summary>
/// <returns>
/// <see cref="true"/> if the <see cref="IHierarchyObject"/> successfully exited the hierarchy;
/// <see cref="false"/> if it failed to do so.
/// </returns>
internal bool ExitHierarchy();
/// <summary>
/// Sets the parent <see cref="IHierarchyObject"/> of this <see cref="IHierarchyObject"/>.
/// </summary>
/// <param name="hierarchyObject">The parent <see cref="IHierarchyObject"/> to set.</param>
void SetParent(IHierarchyObject? hierarchyObject);
/// <summary>
/// Adds a child <see cref="IHierarchyObject"/> to this <see cref="IHierarchyObject"/>.
/// </summary>
/// <param name="hierarchyObject">The child <see cref="IHierarchyObject"/> to add.</param>
void AddChild(IHierarchyObject hierarchyObject);
/// <summary>
/// Removes a child <see cref="IHierarchyObject"/> from this <see cref="IHierarchyObject"/>.
/// </summary>
/// <param name="hierarchyObject">The child <see cref="IHierarchyObject"/> to remove.</param>
void RemoveChild(IHierarchyObject hierarchyObject);
/// <summary>
/// EventHandler delegate for the event triggered when the <see cref="IHierarchyObject"/> enters the hierarchy of a <see cref="IGameManager">.
/// </summary>
/// <param name="sender">The <see cref="IHierarchyObject"/> that entered the hierarchy.</param>
/// <param name="gameManager">The <see cref="IGameManager"/> that the <see cref="IHierarchyObject"/> has entered it's hierarchy.</param>
delegate void EnteredHierarchyEventHandler(IHierarchyObject sender, IGameManager gameManager);
/// <summary>
/// EventHandler delegate for the event triggered when the <see cref="IHierarchyObject"/> exits the hierarchy of a <see cref="IGameManager">.
/// </summary>
/// <param name="sender">The <see cref="IHierarchyObject"/> that exited the hierarchy.</param>
/// <param name="gameManager">The <see cref="IGameManager"/> that the <see cref="IHierarchyObject"/> has exited it's hierarchy.</param>
delegate void ExitedHierarchyEventHandler(IHierarchyObject sender, IGameManager gameManager);
/// <summary>
/// Delegate for the event triggered when the <see cref="IHierarchyObject"/>'s parent changes.
/// </summary>
/// <param name="sender">The <see cref="IHierarchyObject"/> that the parent has changed.</param>
/// <param name="previousParent">The previous <see cref="IHierarchyObject"/> the sender was a child of.</param>
/// <param name="newParent">The new and current <see cref="IHierarchyObject"/> the sender is a child of.</param>
delegate void ParentChangedEventHandler(IHierarchyObject sender, IHierarchyObject? previousParent, IHierarchyObject? newParent);
/// <summary>
/// Delegate for the event triggered when a new <see cref="IHierarchyObject"/> added as a child.
/// </summary>
/// <param name="sender">The parent <see cref="IHierarchyObject"/> this event is being called from.</param>
/// <param name="childrenAdded">The <see cref="IHierarchyObject"/> that got removed as a children of the sender <see cref="IHierarchyObject"/>.</param>
delegate void ChildrenAddedEventHandler(IHierarchyObject sender, IHierarchyObject childrenAdded);
/// <summary>
/// Delegate for the event triggered when a new <see cref="IHierarchyObject"/> removed from being a child.
/// </summary>
/// <param name="sender">The parent <see cref="IHierarchyObject"/> this event is being called from.</param>
/// <param name="childrenAdded">The <see cref="IHierarchyObject"/> that got removed as a children of the sender <see cref="IHierarchyObject"/>.</param>
delegate void ChildrenRemovedEventHandler(IHierarchyObject sender, IHierarchyObject childrenRemoved);
}

91
Engine.Core/Abstract/IUniverse.cs Normal file
View File

@ -0,0 +1,91 @@
using System.Collections.Generic;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents a universe responsible for managing <see cref="IUniverseObject"/>s.
/// </summary>
public interface IUniverse : IEntity, IEnumerable<IUniverseObject>
{
/// <summary>
/// Event triggered when <see cref="Update(UniverseTime)"/> is about to be called called on the <see cref="IUniverse"/>.
/// </summary>
event UpdateEventHandler? OnPreUpdate;
/// <summary>
/// Event triggered when <see cref="Update(UniverseTime)"/> is called on the <see cref="IUniverse"/>.
/// </summary>
event UpdateEventHandler? OnUpdate;
/// <summary>
/// Event triggered when <see cref="PreDraw"/> is called on the <see cref="IUniverse"/>.
/// </summary>
event PreDrawEventHandler? OnPreDraw;
/// <summary>
/// Event triggered when a <see cref="IUniverseObject"/> is registered to the <see cref="IUniverse"/>.
/// </summary>
event UniverseObjectRegisteredEventHandler? OnUniverseObjectRegistered;
/// <summary>
/// Event triggered when a <see cref="IUniverseObject"/> is unregistered from the <see cref="IUniverse"/>.
/// </summary>
event UniverseObjectUnRegisteredEventHandler? OnUniverseObjectUnRegistered;
/// <summary>
/// Current time scale the <see cref="IUniverse"/> operates on.
/// </summary>
float TimeScale { get; set; }
/// <summary>
/// Contains time data related to this <see cref="IUniverse"/>.
/// </summary>
UniverseTime Time { get; }
/// <summary>
/// Contains unscaled time data related to this <see cref="IUniverse"/>.
/// </summary>
UniverseTime UnscaledTime { get; }
/// <summary>
/// Gets a read-only list of <see cref="IUniverseObject"/>s managed by the <see cref="IUniverse"/>.
/// </summary>
IReadOnlyList<IUniverseObject> UniverseObjects { get; }
/// <summary>
/// Registers an <see cref="IUniverseObject"/> to the <see cref="IUniverse"/>.
/// </summary>
/// <param name="universeObject">The <see cref="IUniverseObject"/> to register.</param>
void Register(IUniverseObject universeObject);
/// <summary>
/// Instantiates a <see cref="IUniverseObject"/> of type T with the given arguments and registers it to the <see cref="IUniverse"/>.
/// </summary>
/// <typeparam name="T">The type of <see cref="IUniverseObject"/> to instantiate.</typeparam>
/// <param name="args">Constructor parameters for the given type of <see cref="IUniverseObject"/>.</param>
/// <returns>The instantiated <see cref="IUniverseObject"/>.</returns>
T InstantiateUniverseObject<T>(params object?[]? args) where T : class, IUniverseObject;
/// <summary>
/// Removes an <see cref="IUniverseObject"/> from the <see cref="IUniverse"/>.
/// </summary>
/// <param name="universeObject">The <see cref="IUniverseObject"/> to remove.</param>
void Remove(IUniverseObject universeObject);
/// <summary>
/// Updates the <see cref="IUniverse"/> with the given delta time.
/// </summary>
/// <param name="universeTime">Delta time.</param>
void Update(UniverseTime universeTime);
/// <summary>
/// Performs operations that should be done before the draw calls.
/// </summary>
void PreDraw();
delegate void UpdateEventHandler(IUniverse sender, UniverseTime engineTime);
delegate void PreDrawEventHandler(IUniverse sender);
delegate void UniverseObjectRegisteredEventHandler(IUniverse sender, IUniverseObject universeObjectRegistered);
delegate void UniverseObjectUnRegisteredEventHandler(IUniverse sender, IUniverseObject universeObjectUnregistered);
}

131
Engine.Core/Abstract/IUniverseObject.cs Normal file
View File

@ -0,0 +1,131 @@
using System.Collections.Generic;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents an <see cref="IEntity"/> that can enter and exit a universe within the <see cref="IUniverse"/> system.
/// This interface allows for tracking the object's presence in the universe and provides events
/// for notifying when the see enters or exits the universe.
/// </summary>
public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourController, IEnumerable<IUniverseObject>
{
/// <summary>
/// Event triggered when the <see cref="IUniverseObject"/> enters the universe.
/// </summary>
event EnteredUniverseEventHandler? OnEnteredUniverse;
/// <summary>
/// Event triggered when the <see cref="IUniverseObject"/> exits the universe.
/// </summary>
event ExitedUniverseEventHandler? OnExitedUniverse;
/// <summary>
/// Event triggered when the <see cref="Parent"/> of the <see cref="IUniverseObject"/> changes. The second parameter is the old <see cref="IUniverseObject"/>.
/// </summary>
event ParentChangedEventHandler? OnParentChanged;
/// <summary>
/// Event triggered when a new <see cref="IUniverseObject"/> is added to the <see cref="Children"/>.
/// </summary>
event ChildrenAddedEventHandler? OnChildrenAdded;
/// <summary>
/// Event triggered when an <see cref="IUniverseObject"/> is removed from the <see cref="Children"/>.
/// </summary>
event ChildrenRemovedEventHandler? OnChildrenRemoved;
/// <summary>
/// Gets the <see cref="IUniverse"/> this <see cref="IUniverseObject"/> is connected to, if any.
/// </summary>
IUniverse Universe { get; }
/// <summary>
/// Indicates whether the <see cref="IUniverseObject"/> is currently in the universe.
/// </summary>
bool IsInUniverse { get; }
/// <summary>
/// The parent <see cref="IUniverseObject"/> of the <see cref="IUniverseObject"/>.
/// </summary>
IUniverseObject? Parent { get; }
/// <summary>
/// The <see cref="IUniverseObject"/>s that have this <see cref="IUniverseObject"/> as their <see cref="Parent"/>.
/// </summary>
IReadOnlyList<IUniverseObject> Children { get; }
/// <summary>
/// Internal method to handle entering the universe.
/// This should be called by the system to properly manage universe states.
/// </summary>
/// <param name="universe">The <see cref="IUniverse"/> that is managing this universe.</param>
/// <returns>
/// <see cref="true"/> if the <see cref="IUniverseObject"/> successfully entered the universe;
/// <see cref="false"/> if it failed to do so.
/// </returns>
internal bool EnterUniverse(IUniverse universe);
/// <summary>
/// Internal method to handle exiting the universe.
/// This should be called by the system to properly manage universe states.
/// </summary>
/// <returns>
/// <see cref="true"/> if the <see cref="IUniverseObject"/> successfully exited the universe;
/// <see cref="false"/> if it failed to do so.
/// </returns>
internal bool ExitUniverse();
/// <summary>
/// Sets the parent <see cref="IUniverseObject"/> of this <see cref="IUniverseObject"/>.
/// </summary>
/// <param name="universeObject">The parent <see cref="IUniverseObject"/> to set.</param>
void SetParent(IUniverseObject? universeObject);
/// <summary>
/// Adds a child <see cref="IUniverseObject"/> to this <see cref="IUniverseObject"/>.
/// </summary>
/// <param name="universeObject">The child <see cref="IUniverseObject"/> to add.</param>
void AddChild(IUniverseObject universeObject);
/// <summary>
/// Removes a child <see cref="IUniverseObject"/> from this <see cref="IUniverseObject"/>.
/// </summary>
/// <param name="universeObject">The child <see cref="IUniverseObject"/> to remove.</param>
void RemoveChild(IUniverseObject universeObject);
/// <summary>
/// EventHandler delegate for the event triggered when the <see cref="IUniverseObject"/> enters the universe of a <see cref="IUniverse">.
/// </summary>
/// <param name="sender">The <see cref="IUniverseObject"/> that entered the universe.</param>
/// <param name="universe">The <see cref="IUniverse"/> that the <see cref="IUniverseObject"/> has entered it's universe.</param>
delegate void EnteredUniverseEventHandler(IUniverseObject sender, IUniverse universe);
/// <summary>
/// EventHandler delegate for the event triggered when the <see cref="IUniverseObject"/> exits the universe of a <see cref="IUniverse">.
/// </summary>
/// <param name="sender">The <see cref="IUniverseObject"/> that exited the universe.</param>
/// <param name="universe">The <see cref="IUniverse"/> that the <see cref="IUniverseObject"/> has exited it's universe.</param>
delegate void ExitedUniverseEventHandler(IUniverseObject sender, IUniverse universe);
/// <summary>
/// Delegate for the event triggered when the <see cref="IUniverseObject"/>'s parent changes.
/// </summary>
/// <param name="sender">The <see cref="IUniverseObject"/> that the parent has changed.</param>
/// <param name="previousParent">The previous <see cref="IUniverseObject"/> the sender was a child of.</param>
/// <param name="newParent">The new and current <see cref="IUniverseObject"/> the sender is a child of.</param>
delegate void ParentChangedEventHandler(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent);
/// <summary>
/// Delegate for the event triggered when a new <see cref="IUniverseObject"/> added as a child.
/// </summary>
/// <param name="sender">The parent <see cref="IUniverseObject"/> this event is being called from.</param>
/// <param name="childrenAdded">The <see cref="IUniverseObject"/> that got removed as a children of the sender <see cref="IUniverseObject"/>.</param>
delegate void ChildrenAddedEventHandler(IUniverseObject sender, IUniverseObject childrenAdded);
/// <summary>
/// Delegate for the event triggered when a new <see cref="IUniverseObject"/> removed from being a child.
/// </summary>
/// <param name="sender">The parent <see cref="IUniverseObject"/> this event is being called from.</param>
/// <param name="childrenAdded">The <see cref="IUniverseObject"/> that got removed as a children of the sender <see cref="IUniverseObject"/>.</param>
delegate void ChildrenRemovedEventHandler(IUniverseObject sender, IUniverseObject childrenRemoved);
}

54
Engine.Core/ActiveBehaviourCollector.cs
View File

@ -9,7 +9,7 @@ namespace Syntriax.Engine.Core;
public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : class, IBehaviour
{
public event IAssignable.UnassignEventHandler? OnUnassigned = null;
public event IHasGameManager.GameManagerAssignedEventHandler? OnGameManagerAssigned = null;
public event IHasUniverse.UniverseAssignedEventHandler? OnUniverseAssigned = null;
public event IBehaviourCollector<T>.CollectedEventHandler? OnCollected = null;
public event IBehaviourCollector<T>.RemovedEventHandler? OnRemoved = null;
@ -19,29 +19,29 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
protected readonly Dictionary<IActive, T> monitoringActiveToBehaviour = new(32);
public IReadOnlyList<T> Behaviours => activeBehaviours;
public IGameManager GameManager { get; private set; } = null!;
public IUniverse Universe { get; private set; } = null!;
public T this[Index index] => activeBehaviours[index];
public ActiveBehaviourCollector() { }
public ActiveBehaviourCollector(IGameManager gameManager) => Assign(gameManager);
public ActiveBehaviourCollector(IUniverse universe) => Assign(universe);
private void OnHierarchyObjectRegistered(IGameManager manager, IHierarchyObject hierarchyObject)
private void OnUniverseObjectRegistered(IUniverse manager, IUniverseObject universeObject)
{
hierarchyObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
hierarchyObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
universeObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
universeObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
foreach (IBehaviour item in hierarchyObject.BehaviourController)
OnBehaviourAdded(hierarchyObject.BehaviourController, item);
foreach (IBehaviour item in universeObject.BehaviourController)
OnBehaviourAdded(universeObject.BehaviourController, item);
}
private void OnHierarchyObjectUnregistered(IGameManager manager, IHierarchyObject hierarchyObject)
private void OnUniverseObjectUnregistered(IUniverse manager, IUniverseObject universeObject)
{
hierarchyObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
hierarchyObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
universeObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
universeObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
foreach (IBehaviour item in hierarchyObject.BehaviourController)
OnBehaviourRemoved(hierarchyObject.BehaviourController, item);
foreach (IBehaviour item in universeObject.BehaviourController)
OnBehaviourRemoved(universeObject.BehaviourController, item);
}
protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
@ -89,35 +89,35 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
}
}
public bool Assign(IGameManager gameManager)
public bool Assign(IUniverse universe)
{
if (GameManager is not null)
if (Universe is not null)
return false;
foreach (IHierarchyObject hierarchyObject in gameManager.HierarchyObjects)
OnHierarchyObjectRegistered(gameManager, hierarchyObject);
foreach (IUniverseObject universeObject in universe.UniverseObjects)
OnUniverseObjectRegistered(universe, universeObject);
gameManager.OnHierarchyObjectRegistered += OnHierarchyObjectRegistered;
gameManager.OnHierarchyObjectUnRegistered += OnHierarchyObjectUnregistered;
universe.OnUniverseObjectRegistered += OnUniverseObjectRegistered;
universe.OnUniverseObjectUnRegistered += OnUniverseObjectUnregistered;
GameManager = gameManager;
OnGameManagerAssigned?.InvokeSafe(this);
Universe = universe;
OnUniverseAssigned?.InvokeSafe(this);
return true;
}
public bool Unassign()
{
if (GameManager is null)
if (Universe is null)
return false;
foreach (IHierarchyObject hierarchyObject in GameManager.HierarchyObjects)
OnHierarchyObjectUnregistered(GameManager, hierarchyObject);
foreach (IUniverseObject universeObject in Universe.UniverseObjects)
OnUniverseObjectUnregistered(Universe, universeObject);
GameManager.OnHierarchyObjectRegistered -= OnHierarchyObjectRegistered;
GameManager.OnHierarchyObjectUnRegistered -= OnHierarchyObjectUnregistered;
Universe.OnUniverseObjectRegistered -= OnUniverseObjectRegistered;
Universe.OnUniverseObjectUnRegistered -= OnUniverseObjectUnregistered;
GameManager = null!;
Universe = null!;
OnUnassigned?.InvokeSafe(this);
return true;
}

2
Engine.Core/ActiveBehaviourCollectorSorted.cs
View File

@ -26,5 +26,5 @@ public class ActiveBehaviourCollectorSorted<T> : ActiveBehaviourCollector<T> whe
}
public ActiveBehaviourCollectorSorted() { }
public ActiveBehaviourCollectorSorted(IGameManager gameManager, Comparison<T> sortBy) : base(gameManager) => SortBy = sortBy;
public ActiveBehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe) => SortBy = sortBy;
}

28
Engine.Core/Behaviour.cs
View File

@ -6,8 +6,8 @@ public abstract class Behaviour : BehaviourBase
{
private bool isInitializedThisFrame = false;
protected IGameManager GameManager => BehaviourController.HierarchyObject.GameManager;
protected IHierarchyObject HierarchyObject => BehaviourController.HierarchyObject;
protected IUniverse Universe => BehaviourController.UniverseObject.Universe;
protected IUniverseObject UniverseObject => BehaviourController.UniverseObject;
public Behaviour()
{
@ -27,13 +27,13 @@ public abstract class Behaviour : BehaviourBase
BehaviourController.OnPreUpdate += PreUpdate;
BehaviourController.OnPreDraw += PreDraw;
BehaviourController.OnUpdate += Update;
BehaviourController.HierarchyObject.OnEnteredHierarchy += EnteredHierarchy;
BehaviourController.HierarchyObject.OnExitedHierarchy += ExitedHierarchy;
BehaviourController.UniverseObject.OnEnteredUniverse += EnteredUniverse;
BehaviourController.UniverseObject.OnExitedUniverse += ExitedUniverse;
OnInitialize();
if (HierarchyObject.IsInHierarchy)
EnteredHierarchy(HierarchyObject, GameManager);
if (UniverseObject.IsInUniverse)
EnteredUniverse(UniverseObject, Universe);
}
protected virtual void OnFinalize() { }
@ -42,13 +42,13 @@ public abstract class Behaviour : BehaviourBase
BehaviourController.OnPreUpdate -= PreUpdate;
BehaviourController.OnPreDraw -= PreDraw;
BehaviourController.OnUpdate -= Update;
BehaviourController.HierarchyObject.OnEnteredHierarchy -= EnteredHierarchy;
BehaviourController.HierarchyObject.OnExitedHierarchy -= ExitedHierarchy;
BehaviourController.UniverseObject.OnEnteredUniverse -= EnteredUniverse;
BehaviourController.UniverseObject.OnExitedUniverse -= ExitedUniverse;
OnFinalize();
if (HierarchyObject.IsInHierarchy)
ExitedHierarchy(HierarchyObject, GameManager);
if (UniverseObject.IsInUniverse)
ExitedUniverse(UniverseObject, Universe);
}
protected virtual void OnPreUpdatePreActiveCheck() { }
@ -103,9 +103,9 @@ public abstract class Behaviour : BehaviourBase
OnPreDraw();
}
protected virtual void OnEnteredHierarchy(IGameManager gameManager) { }
protected virtual void EnteredHierarchy(IHierarchyObject sender, IGameManager gameManager) => OnEnteredHierarchy(gameManager);
protected virtual void OnEnteredUniverse(IUniverse universe) { }
protected virtual void EnteredUniverse(IUniverseObject sender, IUniverse universe) => OnEnteredUniverse(universe);
protected virtual void OnExitedHierarchy(IGameManager gameManager) { }
protected virtual void ExitedHierarchy(IHierarchyObject sender, IGameManager gameManager) => OnExitedHierarchy(gameManager);
protected virtual void OnExitedUniverse(IUniverse universe) { }
protected virtual void ExitedUniverse(IUniverseObject sender, IUniverse universe) => OnExitedUniverse(universe);
}

4
Engine.Core/Behaviour2D.cs
View File

@ -23,6 +23,6 @@ public abstract class Behaviour2D : Behaviour, IBehaviour2D
protected sealed override void FirstActiveFrame() => base.FirstActiveFrame();
protected sealed override void Update(IBehaviourController behaviourController) => base.Update(behaviourController);
protected sealed override void PreDraw(IBehaviourController behaviourController) => base.PreDraw(behaviourController);
protected sealed override void EnteredHierarchy(IHierarchyObject sender, IGameManager gameManager) => base.EnteredHierarchy(sender, gameManager);
protected sealed override void ExitedHierarchy(IHierarchyObject sender, IGameManager gameManager) => base.ExitedHierarchy(sender, gameManager);
protected sealed override void EnteredUniverse(IUniverseObject sender, IUniverse universe) => base.EnteredUniverse(sender, universe);
protected sealed override void ExitedUniverse(IUniverseObject sender, IUniverse universe) => base.ExitedUniverse(sender, universe);
}

16
Engine.Core/BehaviourBase.cs
View File

@ -38,16 +38,16 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
_behaviourController = behaviourController;
OnAssign(behaviourController);
behaviourController.OnHierarchyObjectAssigned += OnHierarchyObjectAssigned;
if (behaviourController.HierarchyObject is not null)
OnHierarchyObjectAssigned(behaviourController);
behaviourController.OnUniverseObjectAssigned += OnUniverseObjectAssigned;
if (behaviourController.UniverseObject is not null)
OnUniverseObjectAssigned(behaviourController);
OnBehaviourControllerAssigned?.InvokeSafe(this);
return true;
}
private void OnHierarchyObjectAssigned(IHasHierarchyObject sender)
private void OnUniverseObjectAssigned(IHasUniverseObject sender)
{
sender.HierarchyObject.OnActiveChanged += OnHierarchyObjectActiveChanged;
sender.UniverseObject.OnActiveChanged += OnUniverseObjectActiveChanged;
UpdateActive();
}
@ -61,7 +61,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
protected override void UnassignInternal()
{
StateEnable.OnEnabledChanged -= OnStateEnabledChanged;
BehaviourController.OnHierarchyObjectAssigned -= OnHierarchyObjectAssigned;
BehaviourController.OnUniverseObjectAssigned -= OnUniverseObjectAssigned;
base.UnassignInternal();
_behaviourController = null!;
}
@ -73,12 +73,12 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
}
private void OnStateEnabledChanged(IStateEnable sender, bool previousState) => UpdateActive();
private void OnHierarchyObjectActiveChanged(IActive sender, bool previousState) => UpdateActive();
private void OnUniverseObjectActiveChanged(IActive sender, bool previousState) => UpdateActive();
private void UpdateActive()
{
bool previousActive = IsActive;
_isActive = StateEnable.Enabled && _behaviourController.HierarchyObject.IsActive;
_isActive = StateEnable.Enabled && _behaviourController.UniverseObject.IsActive;
if (previousActive != IsActive)
OnActiveChanged?.InvokeSafe(this, previousActive);

58
Engine.Core/BehaviourCollector.cs
View File

@ -9,7 +9,7 @@ namespace Syntriax.Engine.Core;
public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
{
public event IAssignable.UnassignEventHandler? OnUnassigned = null;
public event IHasGameManager.GameManagerAssignedEventHandler? OnGameManagerAssigned = null;
public event IHasUniverse.UniverseAssignedEventHandler? OnUniverseAssigned = null;
public event IBehaviourCollector<T>.CollectedEventHandler? OnCollected = null;
public event IBehaviourCollector<T>.RemovedEventHandler? OnRemoved = null;
@ -17,29 +17,29 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
protected readonly List<T> behaviours = new(32);
public IReadOnlyList<T> Behaviours => behaviours;
public IGameManager GameManager { get; private set; } = null!;
public IUniverse Universe { get; private set; } = null!;
public T this[Index index] => behaviours[index];
public BehaviourCollector() { }
public BehaviourCollector(IGameManager gameManager) => Assign(gameManager);
public BehaviourCollector(IUniverse universe) => Assign(universe);
private void OnHierarchyObjectRegistered(IGameManager manager, IHierarchyObject hierarchyObject)
private void OnUniverseObjectRegistered(IUniverse manager, IUniverseObject universeObject)
{
hierarchyObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
hierarchyObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
universeObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
universeObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
foreach (IBehaviour item in hierarchyObject.BehaviourController)
OnBehaviourAdded(hierarchyObject.BehaviourController, item);
foreach (IBehaviour item in universeObject.BehaviourController)
OnBehaviourAdded(universeObject.BehaviourController, item);
}
private void OnHierarchyObjectUnregistered(IGameManager manager, IHierarchyObject hierarchyObject)
private void OnUniverseObjectUnregistered(IUniverse manager, IUniverseObject universeObject)
{
hierarchyObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
hierarchyObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
universeObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
universeObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
foreach (IBehaviour item in hierarchyObject.BehaviourController)
OnBehaviourRemoved(hierarchyObject.BehaviourController, item);
foreach (IBehaviour item in universeObject.BehaviourController)
OnBehaviourRemoved(universeObject.BehaviourController, item);
}
protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
@ -66,37 +66,37 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
OnRemoved?.InvokeSafe(this, tBehaviour);
}
protected virtual void OnAssign(IGameManager gameManager) { }
public bool Assign(IGameManager gameManager)
protected virtual void OnAssign(IUniverse universe) { }
public bool Assign(IUniverse universe)
{
if (GameManager is not null)
if (Universe is not null)
return false;
foreach (IHierarchyObject hierarchyObject in gameManager.HierarchyObjects)
OnHierarchyObjectRegistered(gameManager, hierarchyObject);
foreach (IUniverseObject universeObject in universe.UniverseObjects)
OnUniverseObjectRegistered(universe, universeObject);
gameManager.OnHierarchyObjectRegistered += OnHierarchyObjectRegistered;
gameManager.OnHierarchyObjectUnRegistered += OnHierarchyObjectUnregistered;
universe.OnUniverseObjectRegistered += OnUniverseObjectRegistered;
universe.OnUniverseObjectUnRegistered += OnUniverseObjectUnregistered;
GameManager = gameManager;
OnAssign(gameManager);
OnGameManagerAssigned?.InvokeSafe(this);
Universe = universe;
OnAssign(universe);
OnUniverseAssigned?.InvokeSafe(this);
return true;
}
public bool Unassign()
{
if (GameManager is null)
if (Universe is null)
return false;
foreach (IHierarchyObject hierarchyObject in GameManager.HierarchyObjects)
OnHierarchyObjectUnregistered(GameManager, hierarchyObject);
foreach (IUniverseObject universeObject in Universe.UniverseObjects)
OnUniverseObjectUnregistered(Universe, universeObject);
GameManager.OnHierarchyObjectRegistered -= OnHierarchyObjectRegistered;
GameManager.OnHierarchyObjectUnRegistered -= OnHierarchyObjectUnregistered;
Universe.OnUniverseObjectRegistered -= OnUniverseObjectRegistered;
Universe.OnUniverseObjectUnRegistered -= OnUniverseObjectUnregistered;
GameManager = null!;
Universe = null!;
OnUnassigned?.InvokeSafe(this);
return true;
}

2
Engine.Core/BehaviourCollectorSorted.cs
View File

@ -26,5 +26,5 @@ public class BehaviourCollectorSorted<T> : BehaviourCollector<T> where T : class
}
public BehaviourCollectorSorted() { }
public BehaviourCollectorSorted(IGameManager gameManager, Comparison<T> sortBy) : base(gameManager) => SortBy = sortBy;
public BehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe) => SortBy = sortBy;
}

32
Engine.Core/BehaviourController.cs
View File

@ -16,7 +16,7 @@ public class BehaviourController : IBehaviourController
public event IBehaviourController.BehaviourAddedEventHandler? OnBehaviourAdded = null;
public event IBehaviourController.BehaviourRemovedEventHandler? OnBehaviourRemoved = null;
public event IHasHierarchyObject.HierarchyObjectAssignedEventHandler? OnHierarchyObjectAssigned = null;
public event IHasUniverseObject.UniverseObjectAssignedEventHandler? OnUniverseObjectAssigned = null;
public event IInitializable.InitializedEventHandler? OnInitialized = null;
public event IInitializable.FinalizedEventHandler? OnFinalized = null;
@ -25,10 +25,10 @@ public class BehaviourController : IBehaviourController
private readonly IList<IBehaviour> behaviours = new List<IBehaviour>(Constants.BEHAVIOURS_SIZE_INITIAL);
private IHierarchyObject _hierarchyObject = null!;
private IUniverseObject _universeObject = null!;
private bool _initialized = false;
public IHierarchyObject HierarchyObject => _hierarchyObject;
public IUniverseObject UniverseObject => _universeObject;
public bool IsInitialized
{
@ -60,7 +60,7 @@ public class BehaviourController : IBehaviourController
}
public T AddBehaviour<T>(params object?[]? args) where T : class, IBehaviour
=> AddBehaviour(Factory.BehaviourFactory.Instantiate<T>(_hierarchyObject, args));
=> AddBehaviour(Factory.BehaviourFactory.Instantiate<T>(_universeObject, args));
public T? GetBehaviour<T>()
{
@ -115,7 +115,7 @@ public class BehaviourController : IBehaviourController
public void RemoveBehaviour<T>(T behaviour) where T : class, IBehaviour
{
if (!behaviours.Contains(behaviour))
throw new Exception($"{behaviour.GetType().Name} does not exist in {HierarchyObject.Name}'s {nameof(IBehaviourController)}.");
throw new Exception($"{behaviour.GetType().Name} does not exist in {UniverseObject.Name}'s {nameof(IBehaviourController)}.");
behaviour.OnPriorityChanged -= OnPriorityChange;
behaviour.Finalize();
@ -123,15 +123,15 @@ public class BehaviourController : IBehaviourController
OnBehaviourRemoved?.InvokeSafe(this, behaviour);
}
protected virtual void OnAssign(IHierarchyObject hierarchyObject) { }
public bool Assign(IHierarchyObject hierarchyObject)
protected virtual void OnAssign(IUniverseObject universeObject) { }
public bool Assign(IUniverseObject universeObject)
{
if (HierarchyObject is not null && HierarchyObject.IsInitialized)
if (UniverseObject is not null && UniverseObject.IsInitialized)
return false;
_hierarchyObject = hierarchyObject;
OnAssign(hierarchyObject);
OnHierarchyObjectAssigned?.InvokeSafe(this);
_universeObject = universeObject;
OnAssign(universeObject);
OnUniverseObjectAssigned?.InvokeSafe(this);
return true;
}
@ -140,7 +140,7 @@ public class BehaviourController : IBehaviourController
if (IsInitialized)
return false;
Debug.AssertHelpers.AssertHierarchyObjectAssigned(this);
Debug.AssertHelpers.AssertUniverseObjectAssigned(this);
foreach (IBehaviour behaviour in behaviours)
behaviour.Initialize();
@ -166,14 +166,14 @@ public class BehaviourController : IBehaviourController
if (IsInitialized)
return false;
_hierarchyObject = null!;
_universeObject = null!;
OnUnassigned?.InvokeSafe(this);
return true;
}
public void Update()
{
if (!HierarchyObject.StateEnable.Enabled)
if (!UniverseObject.StateEnable.Enabled)
return;
OnPreUpdate?.InvokeSafe(this);
@ -182,14 +182,14 @@ public class BehaviourController : IBehaviourController
public void UpdatePreDraw()
{
if (!HierarchyObject.StateEnable.Enabled)
if (!UniverseObject.StateEnable.Enabled)
return;
OnPreDraw?.InvokeSafe(this);
}
public BehaviourController() { }
public BehaviourController(IHierarchyObject hierarchyObject) => Assign(hierarchyObject);
public BehaviourController(IUniverseObject universeObject) => Assign(universeObject);
private void InsertBehaviourByPriority<T>(T behaviour) where T : class, IBehaviour
{

12
Engine.Core/CoroutineManager.cs
View File

@ -5,7 +5,7 @@ using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public class CoroutineManager : HierarchyObject
public class CoroutineManager : UniverseObject
{
private readonly List<IEnumerator> enumerators = [];
@ -20,17 +20,17 @@ public class CoroutineManager : HierarchyObject
enumerators.Remove(enumerator);
}
protected override void OnEnteringHierarchy(IGameManager gameManager)
protected override void OnEnteringUniverse(IUniverse universe)
{
gameManager.OnUpdate += OnUpdate;
universe.OnUpdate += OnUpdate;
}
protected override void OnExitingHierarchy(IGameManager gameManager)
protected override void OnExitingUniverse(IUniverse universe)
{
gameManager.OnUpdate -= OnUpdate;
universe.OnUpdate -= OnUpdate;
}
private void OnUpdate(IGameManager sender, EngineTime time)
private void OnUpdate(IUniverse sender, UniverseTime time)
{
for (int i = enumerators.Count - 1; i >= 0; i--)
{

16
Engine.Core/Engine.Core.puml
View File

@ -7,11 +7,11 @@ skinparam nodesep 100
title Core Engine Relations
interface Engine.Core.Abstract.IEntity extends Engine.Core.Abstract.IInitializable {}
interface Engine.Core.Abstract.IHierarchyObject extends Engine.Core.Abstract.IEntity, Engine.Core.Abstract.INameable {}
interface Engine.Core.Abstract.IUniverseObject extends Engine.Core.Abstract.IEntity, Engine.Core.Abstract.INameable {}
interface Engine.Core.Abstract.INameable {}
Engine.Core.Abstract.IHierarchyObject --> Engine.Core.Abstract.IBehaviourController: has
Engine.Core.Abstract.IUniverseObject --> Engine.Core.Abstract.IBehaviourController: has
Engine.Core.Abstract.IBehaviourController "1" --> "0..*" Engine.Core.Abstract.IBehaviour: has
interface Engine.Core.Abstract.IBehaviourController {}
@ -19,18 +19,18 @@ interface Engine.Core.Abstract.IBehaviour {}
interface Engine.Core.Abstract.IBehaviour2D extends Engine.Core.Abstract.IBehaviour {}
interface Engine.Core.Abstract.IBehaviour3D extends Engine.Core.Abstract.IBehaviour {}
interface Engine.Core.Abstract.IGameManager {}
Engine.Core.Abstract.IGameManager "1" -r-> "0..*" Engine.Core.Abstract.IHierarchyObject: has
interface Engine.Core.Abstract.IUniverse {}
Engine.Core.Abstract.IUniverse "1" -r-> "0..*" Engine.Core.Abstract.IUniverseObject: has
' together {
' interface Engine.Core.Abstract.IAssignable {}
' interface Engine.Core.Abstract.IHasStateEnable extends Engine.Core.Abstract.IAssignable {}
' interface Engine.Core.Abstract.IHasGameManager extends Engine.Core.Abstract.IAssignable {}
' interface Engine.Core.Abstract.IHasHierarchyObject extends Engine.Core.Abstract.IAssignable {}
' interface Engine.Core.Abstract.IHasUniverse extends Engine.Core.Abstract.IAssignable {}
' interface Engine.Core.Abstract.IHasUniverseObject extends Engine.Core.Abstract.IAssignable {}
' interface Engine.Core.Abstract.IHasBehaviourController extends Engine.Core.Abstract.IAssignable {}
' ' Engine.Core.Abstract.IHasStateEnable --> Engine.Core.Abstract.IStateEnable: has
' ' Engine.Core.Abstract.IHasGameManager --> Engine.Core.Abstract.IGameManager: has
' ' Engine.Core.Abstract.IHasHierarchyObject --> Engine.Core.Abstract.IHierarchyObject: has
' ' Engine.Core.Abstract.IHasUniverse --> Engine.Core.Abstract.IUniverse: has
' ' Engine.Core.Abstract.IHasUniverseObject --> Engine.Core.Abstract.IUniverseObject: has
' ' Engine.Core.Abstract.IHasBehaviourController --> Engine.Core.Abstract.IBehaviourController: has
' }

9
Engine.Core/Exceptions/HierarchyObjectNotFoundException.cs
View File

@ -1,9 +0,0 @@
using System;
namespace Syntriax.Engine.Core.Exceptions;
public class HierarchyObjectNotFoundException(string? message) : Exception(message)
{
public static NotAssignedException FromType<THierarchyObject>()
=> new($"{typeof(THierarchyObject).FullName} was not found");
}

9
Engine.Core/Exceptions/UniverseObjectNotFoundException.cs Normal file
View File

@ -0,0 +1,9 @@
using System;
namespace Syntriax.Engine.Core.Exceptions;
public class UniverseObjectNotFoundException(string? message) : Exception(message)
{
public static NotAssignedException FromType<TUniverseObject>()
=> new($"{typeof(TUniverseObject).FullName} was not found");
}

24
Engine.Core/Extensions/BehaviourControllerExtensions.cs
View File

@ -27,7 +27,7 @@ public static class BehaviourControllerExtensions
/// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
/// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, throws <see cref="BehaviourNotFoundException"/>.</returns>
public static T GetRequiredBehaviour<T>(this IBehaviourController behaviourController) where T : class
=> behaviourController.GetBehaviour<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.HierarchyObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName}");
=> behaviourController.GetBehaviour<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName}");
/// <summary>
/// Gets an existing <see cref="IBehaviour"/> of the specified type, or adds and returns a new one if it doesn't exist.
@ -40,12 +40,12 @@ public static class BehaviourControllerExtensions
=> behaviourController.GetBehaviour<T>() ?? behaviourController.AddBehaviour<T>(args);
/// <summary>
/// Tries to get a <see cref="IBehaviour"/> of the specified type in it's <see cref="IHierarchyObject"/>'s parents recursively.
/// Tries to get a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s parents recursively.
/// </summary>
/// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
/// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
/// <param name="behaviour">When this method returns, contains the <see cref="IBehaviour"/> of the specified type, if found; otherwise, null.</param>
/// <returns><see cref="true"/> if a <see cref="IBehaviour"/> of the specified type was found in the parent hierarchy; otherwise, <see cref="false"/>.</returns>
/// <returns><see cref="true"/> if a <see cref="IBehaviour"/> of the specified type was found in the parent universe; otherwise, <see cref="false"/>.</returns>
public static bool TryGetBehaviourInParent<T>(this IBehaviourController behaviourController, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
{
behaviour = GetBehaviourInParent<T>(behaviourController);
@ -53,7 +53,7 @@ public static class BehaviourControllerExtensions
}
/// <summary>
/// Gets a <see cref="IBehaviour"/> of the specified type in it's <see cref="IHierarchyObject"/>'s parents recursively.
/// Gets a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s parents recursively.
/// </summary>
/// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
/// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
@ -67,28 +67,28 @@ public static class BehaviourControllerExtensions
if (controller.GetBehaviour<T>() is T behaviour)
return behaviour;
controller = controller.HierarchyObject.Parent?.BehaviourController;
controller = controller.UniverseObject.Parent?.BehaviourController;
}
return default;
}
/// <summary>
/// Gets a <see cref="IBehaviour"/> of the specified type in it's <see cref="IHierarchyObject"/>'s parents recursively. Throws an error if not found.
/// Gets a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s parents recursively. Throws an error if not found.
/// </summary>
/// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
/// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
/// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, throws <see cref="BehaviourNotFoundException"/>.</returns>
public static T GetRequiredBehaviourInParent<T>(this IBehaviourController behaviourController) where T : class
=> behaviourController.GetBehaviourInParent<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.HierarchyObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any parent");
=> behaviourController.GetBehaviourInParent<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any parent");
/// <summary>
/// Tries to get a <see cref="IBehaviour"/> of the specified type in it's <see cref="IHierarchyObject"/>'s children recursively.
/// Tries to get a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s children recursively.
/// </summary>
/// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
/// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
/// <param name="behaviour">When this method returns, contains the <see cref="IBehaviour"/> of the specified type, if found; otherwise, null.</param>
/// <returns><see cref="true"/> if a <see cref="IBehaviour"/> of the specified type was found in the child hierarchy; otherwise, <see cref="false"/>.</returns>
/// <returns><see cref="true"/> if a <see cref="IBehaviour"/> of the specified type was found in the child universe; otherwise, <see cref="false"/>.</returns>
public static bool TryGetBehaviourInChildren<T>(this IBehaviourController behaviourController, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
{
behaviour = GetBehaviourInChildren<T>(behaviourController);
@ -96,7 +96,7 @@ public static class BehaviourControllerExtensions
}
/// <summary>
/// Gets a <see cref="IBehaviour"/> of the specified type in it's <see cref="IHierarchyObject"/>'s children recursively.
/// Gets a <see cref="IBehaviour"/> of the specified type in it's <see cref="IUniverseObject"/>'s children recursively.
/// </summary>
/// <typeparam name="T">The type of <see cref="IBehaviour"/> to get.</typeparam>
/// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
@ -106,7 +106,7 @@ public static class BehaviourControllerExtensions
if (behaviourController.GetBehaviour<T>() is T localBehaviour)
return localBehaviour;
foreach (IHierarchyObject child in behaviourController.HierarchyObject)
foreach (IUniverseObject child in behaviourController.UniverseObject)
if (GetBehaviourInChildren<T>(child.BehaviourController) is T behaviour)
return behaviour;
@ -120,5 +120,5 @@ public static class BehaviourControllerExtensions
/// <param name="behaviourController">The <see cref="IBehaviourController"/> to start searching from.</param>
/// <returns>The <see cref="IBehaviour"/> of the specified type if found; otherwise, throws <see cref="BehaviourNotFoundException"/>.</returns>
public static T GetRequiredBehaviourInChildren<T>(this IBehaviourController behaviourController) where T : class
=> behaviourController.GetBehaviourInChildren<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.HierarchyObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any children ");
=> behaviourController.GetBehaviourInChildren<T>() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any children ");
}

16
Engine.Core/Extensions/BehaviourExtensions.cs
View File

@ -7,29 +7,29 @@ namespace Syntriax.Engine.Core;
public static class BehaviourExtensions
{
public static T? FindBehaviour<T>(this IEnumerable<IHierarchyObject> hierarchyObjects) where T : class
public static T? FindBehaviour<T>(this IEnumerable<IUniverseObject> universeObjects) where T : class
{
foreach (IHierarchyObject hierarchyObject in hierarchyObjects)
if (hierarchyObject.BehaviourController.GetBehaviour<T>() is T behaviour)
foreach (IUniverseObject universeObject in universeObjects)
if (universeObject.BehaviourController.GetBehaviour<T>() is T behaviour)
return behaviour;
return default;
}
public static bool TryFindBehaviour<T>(this IEnumerable<IHierarchyObject> hierarchyObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
public static bool TryFindBehaviour<T>(this IEnumerable<IUniverseObject> universeObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
{
behaviour = FindBehaviour<T>(hierarchyObjects);
behaviour = FindBehaviour<T>(universeObjects);
return behaviour is not null;
}
public static void FindBehaviours<T>(this IEnumerable<IHierarchyObject> hierarchyObjects, List<T> behaviours) where T : class
public static void FindBehaviours<T>(this IEnumerable<IUniverseObject> universeObjects, List<T> behaviours) where T : class
{
behaviours.Clear();
List<T> cache = [];
foreach (IHierarchyObject hierarchyObject in hierarchyObjects)
foreach (IUniverseObject universeObject in universeObjects)
{
hierarchyObject.BehaviourController.GetBehaviours(cache);
universeObject.BehaviourController.GetBehaviours(cache);
behaviours.AddRange(cache);
}
}

16
Engine.Core/Extensions/GameManagerExtensions.cs
View File

@ -1,16 +0,0 @@
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Core.Exceptions;
namespace Syntriax.Engine.Core;
public static class GameManagerExtensions
{
public static IHierarchyObject InstantiateHierarchyObject(this IGameManager gameManager, params object?[]? args)
=> gameManager.InstantiateHierarchyObject<HierarchyObject>(args);
public static T GetRequiredHierarchyObject<T>(this IGameManager gameManager) where T : class
=> gameManager.GetHierarchyObject<T>() ?? throw new HierarchyObjectNotFoundException($"{gameManager.GetType().FullName}({gameManager.Id}) does not contain any {nameof(IHierarchyObject)} object of type {typeof(T).FullName}");
public static T FindRequiredBehaviour<T>(this IGameManager gameManager) where T : class
=> gameManager.FindBehaviour<T>() ?? throw new BehaviourNotFoundException($"{gameManager.GetType().FullName}({gameManager.Id}) does not contain any {nameof(IHierarchyObject)} with {nameof(IBehaviour)} of type {typeof(T).FullName}");
}

41
Engine.Core/Extensions/HierarchyObjectExtensions.cs
View File

@ -1,41 +0,0 @@
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public static class HierarchyObjectExtensions
{
public static T SetHierarchyObject<T>(this T hierarchyObject, string? name = "", IHierarchyObject? parent = null) where T : IHierarchyObject
{
if (!string.IsNullOrWhiteSpace(name))
hierarchyObject.Name = name;
if (parent is not null)
hierarchyObject.SetParent(parent);
return hierarchyObject;
}
public static T? GetHierarchyObject<T>(this IEnumerable<IHierarchyObject> hierarchyObjects) where T : class
{
foreach (IHierarchyObject hierarchyObject in hierarchyObjects)
if (hierarchyObject is T @object)
return @object;
return default;
}
public static bool TryGetHierarchyObject<T>(this IEnumerable<IHierarchyObject> hierarchyObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
{
behaviour = GetHierarchyObject<T>(hierarchyObjects);
return behaviour is not null;
}
public static void GetHierarchyObjects<T>(this IEnumerable<IHierarchyObject> hierarchyObjects, List<T> behaviours) where T : class
{
behaviours.Clear();
foreach (IHierarchyObject hierarchyObject in hierarchyObjects)
if (hierarchyObject is T @object)
behaviours.Add(@object);
}
}

16
Engine.Core/Extensions/UniverseExtensions.cs Normal file
View File

@ -0,0 +1,16 @@
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Core.Exceptions;
namespace Syntriax.Engine.Core;
public static class UniverseExtensions
{
public static IUniverseObject InstantiateUniverseObject(this IUniverse universe, params object?[]? args)
=> universe.InstantiateUniverseObject<UniverseObject>(args);
public static T GetRequiredUniverseObject<T>(this IUniverse universe) where T : class
=> universe.GetUniverseObject<T>() ?? throw new UniverseObjectNotFoundException($"{universe.GetType().FullName}({universe.Id}) does not contain any {nameof(IUniverseObject)} object of type {typeof(T).FullName}");
public static T FindRequiredBehaviour<T>(this IUniverse universe) where T : class
=> universe.FindBehaviour<T>() ?? throw new BehaviourNotFoundException($"{universe.GetType().FullName}({universe.Id}) does not contain any {nameof(IUniverseObject)} with {nameof(IBehaviour)} of type {typeof(T).FullName}");
}

41
Engine.Core/Extensions/UniverseObjectExtensions.cs Normal file
View File

@ -0,0 +1,41 @@
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public static class UniverseObjectExtensions
{
public static T SetUniverseObject<T>(this T universeObject, string? name = "", IUniverseObject? parent = null) where T : IUniverseObject
{
if (!string.IsNullOrWhiteSpace(name))
universeObject.Name = name;
if (parent is not null)
universeObject.SetParent(parent);
return universeObject;
}
public static T? GetUniverseObject<T>(this IEnumerable<IUniverseObject> universeObjects) where T : class
{
foreach (IUniverseObject universeObject in universeObjects)
if (universeObject is T @object)
return @object;
return default;
}
public static bool TryGetUniverseObject<T>(this IEnumerable<IUniverseObject> universeObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
{
behaviour = GetUniverseObject<T>(universeObjects);
return behaviour is not null;
}
public static void GetUniverseObjects<T>(this IEnumerable<IUniverseObject> universeObjects, List<T> behaviours) where T : class
{
behaviours.Clear();
foreach (IUniverseObject universeObject in universeObjects)
if (universeObject is T @object)
behaviours.Add(@object);
}
}

14
Engine.Core/Factory/BehaviourControllerFactory.cs
View File

@ -5,19 +5,19 @@ namespace Syntriax.Engine.Core.Factory;
public class BehaviourControllerFactory
{
public static IBehaviourController Instantiate(IHierarchyObject hierarchyObject)
=> Instantiate<BehaviourController>(hierarchyObject);
public static IBehaviourController Instantiate(IUniverseObject universeObject)
=> Instantiate<BehaviourController>(universeObject);
public static T Instantiate<T>(IHierarchyObject hierarchyObject, params object?[]? args)
public static T Instantiate<T>(IUniverseObject universeObject, params object?[]? args)
where T : class, IBehaviourController
{
T behaviourController = TypeFactory.Get<T>(args);
if (!hierarchyObject.Assign(behaviourController))
throw AssignFailedException.From(hierarchyObject, behaviourController);
if (!universeObject.Assign(behaviourController))
throw AssignFailedException.From(universeObject, behaviourController);
if (!behaviourController.Assign(hierarchyObject))
throw AssignFailedException.From(behaviourController, hierarchyObject);
if (!behaviourController.Assign(universeObject))
throw AssignFailedException.From(behaviourController, universeObject);
return behaviourController;
}

10
Engine.Core/Factory/BehaviourFactory.cs
View File

@ -5,10 +5,10 @@ namespace Syntriax.Engine.Core.Factory;
public class BehaviourFactory
{
public static T Instantiate<T>(IHierarchyObject hierarchyObject, params object?[]? args) where T : class, IBehaviour
=> Instantiate<T>(hierarchyObject, stateEnable: null, args);
public static T Instantiate<T>(IUniverseObject universeObject, params object?[]? args) where T : class, IBehaviour
=> Instantiate<T>(universeObject, stateEnable: null, args);
public static T Instantiate<T>(IHierarchyObject hierarchyObject, IStateEnable? stateEnable, params object?[]? args)
public static T Instantiate<T>(IUniverseObject universeObject, IStateEnable? stateEnable, params object?[]? args)
where T : class, IBehaviour
{
T behaviour = TypeFactory.Get<T>(args);
@ -19,8 +19,8 @@ public class BehaviourFactory
if (!behaviour.Assign(stateEnable))
throw AssignFailedException.From(behaviour, stateEnable);
if (!behaviour.Assign(hierarchyObject.BehaviourController))
throw AssignFailedException.From(behaviour, hierarchyObject.BehaviourController);
if (!behaviour.Assign(universeObject.BehaviourController))
throw AssignFailedException.From(behaviour, universeObject.BehaviourController);
return behaviour;
}

37
Engine.Core/Factory/HierarchyObjectFactory.cs
View File

@ -1,37 +0,0 @@
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Core.Exceptions;
namespace Syntriax.Engine.Core.Factory;
public class HierarchyObjectFactory
{
public static IHierarchyObject Instantiate() => Instantiate<HierarchyObject>();
public static T Instantiate<T>(params object?[]? args) where T : class, IHierarchyObject
=> Instantiate<T>(behaviourController: null, stateEnable: null, args);
public static IHierarchyObject Instantiate(IBehaviourController? behaviourController = null, IStateEnable? stateEnable = null) => Instantiate<HierarchyObject>(behaviourController, stateEnable);
public static T Instantiate<T>(
IBehaviourController? behaviourController = null,
IStateEnable? stateEnable = null,
params object?[]? args
)
where T : class, IHierarchyObject
{
T hierarchyObject = TypeFactory.Get<T>(args);
behaviourController ??= TypeFactory.Get<BehaviourController>();
stateEnable ??= TypeFactory.Get<StateEnable>();
if (!behaviourController.Assign(hierarchyObject))
throw AssignFailedException.From(behaviourController, hierarchyObject);
if (!stateEnable.Assign(hierarchyObject))
throw AssignFailedException.From(stateEnable, hierarchyObject);
if (!hierarchyObject.Assign(behaviourController))
throw AssignFailedException.From(hierarchyObject, behaviourController);
if (!hierarchyObject.Assign(stateEnable))
throw AssignFailedException.From(hierarchyObject, stateEnable);
return hierarchyObject;
}
}

37
Engine.Core/Factory/UniverseObjectFactory.cs Normal file
View File

@ -0,0 +1,37 @@
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Core.Exceptions;
namespace Syntriax.Engine.Core.Factory;
public class UniverseObjectFactory
{
public static IUniverseObject Instantiate() => Instantiate<UniverseObject>();
public static T Instantiate<T>(params object?[]? args) where T : class, IUniverseObject
=> Instantiate<T>(behaviourController: null, stateEnable: null, args);
public static IUniverseObject Instantiate(IBehaviourController? behaviourController = null, IStateEnable? stateEnable = null) => Instantiate<UniverseObject>(behaviourController, stateEnable);
public static T Instantiate<T>(
IBehaviourController? behaviourController = null,
IStateEnable? stateEnable = null,
params object?[]? args
)
where T : class, IUniverseObject
{
T universeObject = TypeFactory.Get<T>(args);
behaviourController ??= TypeFactory.Get<BehaviourController>();
stateEnable ??= TypeFactory.Get<StateEnable>();
if (!behaviourController.Assign(universeObject))
throw AssignFailedException.From(behaviourController, universeObject);
if (!stateEnable.Assign(universeObject))
throw AssignFailedException.From(stateEnable, universeObject);
if (!universeObject.Assign(behaviourController))
throw AssignFailedException.From(universeObject, behaviourController);
if (!universeObject.Assign(stateEnable))
throw AssignFailedException.From(universeObject, stateEnable);
return universeObject;
}
}

141
Engine.Core/GameManager.cs
View File

@ -1,141 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
[System.Diagnostics.DebuggerDisplay("HierarchyObject Count: {_hierarchyObjects.Count}")]
public class GameManager : BaseEntity, IGameManager
{
public event IGameManager.UpdateEventHandler? OnPreUpdate = null;
public event IGameManager.UpdateEventHandler? OnUpdate = null;
public event IGameManager.PreDrawEventHandler? OnPreDraw = null;
public event IGameManager.HierarchyObjectRegisteredEventHandler? OnHierarchyObjectRegistered = null;
public event IGameManager.HierarchyObjectUnRegisteredEventHandler? OnHierarchyObjectUnRegistered = null;
private readonly List<IHierarchyObject> _hierarchyObjects = new(Constants.GAME_OBJECTS_SIZE_INITIAL);
private float _timeScale = 1f;
public IReadOnlyList<IHierarchyObject> HierarchyObjects => _hierarchyObjects;
public EngineTime Time { get; private set; } = new();
public EngineTime UnscaledTime { get; private set; } = new();
public float TimeScale
{
get => _timeScale;
set => _timeScale = value.Max(0f);
}
public void Register(IHierarchyObject hierarchyObject)
{
if (_hierarchyObjects.Contains(hierarchyObject))
throw new Exception($"{nameof(IHierarchyObject)} named {hierarchyObject.Name} is already registered to the {nameof(GameManager)}.");
hierarchyObject.OnFinalized += OnHierarchyObjectFinalize;
hierarchyObject.OnExitedHierarchy += OnHierarchyObjectExitedHierarchy;
if (!hierarchyObject.Initialize())
throw new Exception($"{hierarchyObject.Name} can't be initialized");
for (int i = 0; i < hierarchyObject.Children.Count; i++)
Register(hierarchyObject.Children[i]);
_hierarchyObjects.Add(hierarchyObject);
if (!hierarchyObject.EnterHierarchy(this))
throw new Exception($"{hierarchyObject.Name} can't enter the hierarchy");
OnHierarchyObjectRegistered?.InvokeSafe(this, hierarchyObject);
}
public T InstantiateHierarchyObject<T>(params object?[]? args) where T : class, IHierarchyObject
{
T hierarchyObject = Factory.HierarchyObjectFactory.Instantiate<T>(args);
Register(hierarchyObject);
return hierarchyObject;
}
public void Remove(IHierarchyObject hierarchyObject)
{
hierarchyObject.SetParent(null);
RemoveIncursive(hierarchyObject);
}
private void RemoveIncursive(IHierarchyObject hierarchyObject)
{
if (!_hierarchyObjects.Contains(hierarchyObject))
throw new Exception($"{nameof(IHierarchyObject)} named {hierarchyObject.Name} is not registered to the {nameof(GameManager)}.");
hierarchyObject.OnFinalized -= OnHierarchyObjectFinalize;
hierarchyObject.OnExitedHierarchy -= OnHierarchyObjectExitedHierarchy;
for (int i = hierarchyObject.Children.Count - 1; i >= 0; i--)
Remove(hierarchyObject.Children[i]);
_hierarchyObjects.Remove(hierarchyObject);
if (!hierarchyObject.ExitHierarchy())
throw new Exception($"{hierarchyObject.Name} can't exit the hierarchy");
if (!hierarchyObject.Finalize())
throw new Exception($"{hierarchyObject.Name} can't be finalized");
OnHierarchyObjectUnRegistered?.InvokeSafe(this, hierarchyObject);
}
protected override void InitializeInternal()
{
foreach (IHierarchyObject hierarchyObject in HierarchyObjects)
hierarchyObject.Initialize();
}
protected override void FinalizeInternal()
{
base.FinalizeInternal();
for (int i = HierarchyObjects.Count; i >= 0; i--)
HierarchyObjects[i].Finalize();
}
public void Update(EngineTime engineTime)
{
Debug.AssertHelpers.AssertInitialized(this);
UnscaledTime = engineTime;
Time = new(TimeSpan.FromTicks((long)(Time.TimeSinceStart.Ticks + engineTime.DeltaSpan.Ticks * TimeScale)), TimeSpan.FromTicks((long)(engineTime.DeltaSpan.Ticks * TimeScale)));
OnPreUpdate?.InvokeSafe(this, Time);
for (int i = 0; i < HierarchyObjects.Count; i++)
HierarchyObjects[i].BehaviourController.Update();
OnUpdate?.InvokeSafe(this, Time);
}
public void PreDraw()
{
Debug.AssertHelpers.AssertInitialized(this);
for (int i = 0; i < HierarchyObjects.Count; i++)
HierarchyObjects[i].BehaviourController.UpdatePreDraw();
OnPreDraw?.InvokeSafe(this);
}
private void OnHierarchyObjectFinalize(IInitializable initializable)
{
if (initializable is IHierarchyObject hierarchyObject)
Remove(hierarchyObject);
}
private void OnHierarchyObjectExitedHierarchy(IHierarchyObject sender, IGameManager gameManager)
{
if (sender is IHierarchyObject hierarchyObject)
Remove(hierarchyObject);
}
public IEnumerator<IHierarchyObject> GetEnumerator() => _hierarchyObjects.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => _hierarchyObjects.GetEnumerator();
}

8
Engine.Core/Helpers/AssertHelpers.cs
View File

@ -19,12 +19,12 @@ public class AssertHelpers
=> System.Diagnostics.Debug.Assert(assignable.Entity is not null, $"{assignable.GetType().Name} must be initialized");
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void AssertGameManagerAssigned(IHasGameManager assignable)
=> System.Diagnostics.Debug.Assert(assignable.GameManager is not null, $"{assignable.GetType().Name} must be initialized");
public static void AssertUniverseAssigned(IHasUniverse assignable)
=> System.Diagnostics.Debug.Assert(assignable.Universe is not null, $"{assignable.GetType().Name} must be initialized");
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void AssertHierarchyObjectAssigned(IHasHierarchyObject assignable)
=> System.Diagnostics.Debug.Assert(assignable.HierarchyObject is not null, $"{assignable.GetType().Name} must be initialized");
public static void AssertUniverseObjectAssigned(IHasUniverseObject assignable)
=> System.Diagnostics.Debug.Assert(assignable.UniverseObject is not null, $"{assignable.GetType().Name} must be initialized");
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void AssertStateEnableAssigned(IHasStateEnable assignable)

3
Engine.Core/Static/Internal/Constants.cs
View File

@ -3,6 +3,5 @@ namespace Syntriax.Engine.Core;
internal static class Constants
{
internal static int BEHAVIOURS_SIZE_INITIAL = 16;
internal static int GAME_OBJECTS_SIZE_INITIAL = 256;
internal static int DRAWABLE_OBJECTS_SIZE_INITIAL = 256;
internal static int UNIVERSE_OBJECTS_SIZE_INITIAL = 256;
}

22
Engine.Core/Transform2D.cs
View File

@ -2,7 +2,7 @@ using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
[System.Diagnostics.DebuggerDisplay("Name: {HierarchyObject.Name, nq} Position: {Position.ToString(), nq}, Scale: {Scale.ToString(), nq}, Rotation: {Rotation}")]
[System.Diagnostics.DebuggerDisplay("Name: {UniverseObject.Name, nq} Position: {Position.ToString(), nq}, Scale: {Scale.ToString(), nq}, Rotation: {Rotation}")]
public class Transform2D : Behaviour, ITransform2D
{
public event ITransform2D.PositionChangedEventHandler? OnPositionChanged = null;
@ -206,16 +206,16 @@ public class Transform2D : Behaviour, ITransform2D
protected override void InitializeInternal()
{
UpdateReferences(HierarchyObject.Parent);
HierarchyObject.OnParentChanged += OnParentChanged;
UpdateReferences(UniverseObject.Parent);
UniverseObject.OnParentChanged += OnParentChanged;
}
protected override void FinalizeInternal()
{
HierarchyObject.OnParentChanged -= OnParentChanged;
UniverseObject.OnParentChanged -= OnParentChanged;
}
private void UpdateReferences(IHierarchyObject? parent)
private void UpdateReferences(IUniverseObject? parent)
{
ITransform2D? previousParent = parentTransform;
if (previousParent is not null)
@ -223,7 +223,7 @@ public class Transform2D : Behaviour, ITransform2D
previousParent.OnPositionChanged -= RecalculatePosition;
previousParent.OnScaleChanged -= RecalculateScale;
previousParent.OnRotationChanged -= RecalculateRotation;
previousParent.BehaviourController.HierarchyObject.OnParentChanged -= OnParentChanged;
previousParent.BehaviourController.UniverseObject.OnParentChanged -= OnParentChanged;
previousParent.BehaviourController.OnBehaviourAdded -= LookForTransform2D;
}
@ -234,14 +234,14 @@ public class Transform2D : Behaviour, ITransform2D
parentTransform.OnPositionChanged += RecalculatePosition;
parentTransform.OnScaleChanged += RecalculateScale;
parentTransform.OnRotationChanged += RecalculateRotation;
parentTransform.BehaviourController.HierarchyObject.OnParentChanged += OnParentChanged;
parentTransform.BehaviourController.UniverseObject.OnParentChanged += OnParentChanged;
UpdatePosition();
UpdateScale();
UpdateRotation();
}
else if (HierarchyObject.Parent is not null)
HierarchyObject.Parent.BehaviourController.OnBehaviourAdded += LookForTransform2D;
else if (UniverseObject.Parent is not null)
UniverseObject.Parent.BehaviourController.OnBehaviourAdded += LookForTransform2D;
UpdateLocalPosition();
UpdateLocalScale();
@ -257,10 +257,10 @@ public class Transform2D : Behaviour, ITransform2D
if (behaviourAdded is not ITransform2D transform2D)
return;
UpdateReferences(HierarchyObject.Parent);
UpdateReferences(UniverseObject.Parent);
}
private void OnParentChanged(IHierarchyObject sender, IHierarchyObject? previousParent, IHierarchyObject? newParent)
private void OnParentChanged(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent)
{
UpdateReferences(newParent);
}

141
Engine.Core/Universe.cs Normal file
View File

@ -0,0 +1,141 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
[System.Diagnostics.DebuggerDisplay("UniverseObject Count: {_universeObjects.Count}")]
public class Universe : BaseEntity, IUniverse
{
public event IUniverse.UpdateEventHandler? OnPreUpdate = null;
public event IUniverse.UpdateEventHandler? OnUpdate = null;
public event IUniverse.PreDrawEventHandler? OnPreDraw = null;
public event IUniverse.UniverseObjectRegisteredEventHandler? OnUniverseObjectRegistered = null;
public event IUniverse.UniverseObjectUnRegisteredEventHandler? OnUniverseObjectUnRegistered = null;
private readonly List<IUniverseObject> _universeObjects = new(Constants.UNIVERSE_OBJECTS_SIZE_INITIAL);
private float _timeScale = 1f;
public IReadOnlyList<IUniverseObject> UniverseObjects => _universeObjects;
public UniverseTime Time { get; private set; } = new();
public UniverseTime UnscaledTime { get; private set; } = new();
public float TimeScale
{
get => _timeScale;
set => _timeScale = value.Max(0f);
}
public void Register(IUniverseObject universeObject)
{
if (_universeObjects.Contains(universeObject))
throw new Exception($"{nameof(IUniverseObject)} named {universeObject.Name} is already registered to the {nameof(Universe)}.");
universeObject.OnFinalized += OnUniverseObjectFinalize;
universeObject.OnExitedUniverse += OnUniverseObjectExitedUniverse;
if (!universeObject.Initialize())
throw new Exception($"{universeObject.Name} can't be initialized");
for (int i = 0; i < universeObject.Children.Count; i++)
Register(universeObject.Children[i]);
_universeObjects.Add(universeObject);
if (!universeObject.EnterUniverse(this))
throw new Exception($"{universeObject.Name} can't enter the universe");
OnUniverseObjectRegistered?.InvokeSafe(this, universeObject);
}
public T InstantiateUniverseObject<T>(params object?[]? args) where T : class, IUniverseObject
{
T universeObject = Factory.UniverseObjectFactory.Instantiate<T>(args);
Register(universeObject);
return universeObject;
}
public void Remove(IUniverseObject universeObject)
{
universeObject.SetParent(null);
RemoveIncursive(universeObject);
}
private void RemoveIncursive(IUniverseObject universeObject)
{
if (!_universeObjects.Contains(universeObject))
throw new Exception($"{nameof(IUniverseObject)} named {universeObject.Name} is not registered to the {nameof(Universe)}.");
universeObject.OnFinalized -= OnUniverseObjectFinalize;
universeObject.OnExitedUniverse -= OnUniverseObjectExitedUniverse;
for (int i = universeObject.Children.Count - 1; i >= 0; i--)
Remove(universeObject.Children[i]);
_universeObjects.Remove(universeObject);
if (!universeObject.ExitUniverse())
throw new Exception($"{universeObject.Name} can't exit the universe");
if (!universeObject.Finalize())
throw new Exception($"{universeObject.Name} can't be finalized");
OnUniverseObjectUnRegistered?.InvokeSafe(this, universeObject);
}
protected override void InitializeInternal()
{
foreach (IUniverseObject universeObject in UniverseObjects)
universeObject.Initialize();
}
protected override void FinalizeInternal()
{
base.FinalizeInternal();
for (int i = UniverseObjects.Count; i >= 0; i--)
UniverseObjects[i].Finalize();
}
public void Update(UniverseTime engineTime)
{
Debug.AssertHelpers.AssertInitialized(this);
UnscaledTime = engineTime;
Time = new(TimeSpan.FromTicks((long)(Time.TimeSinceStart.Ticks + engineTime.DeltaSpan.Ticks * TimeScale)), TimeSpan.FromTicks((long)(engineTime.DeltaSpan.Ticks * TimeScale)));
OnPreUpdate?.InvokeSafe(this, Time);
for (int i = 0; i < UniverseObjects.Count; i++)
UniverseObjects[i].BehaviourController.Update();
OnUpdate?.InvokeSafe(this, Time);
}
public void PreDraw()
{
Debug.AssertHelpers.AssertInitialized(this);
for (int i = 0; i < UniverseObjects.Count; i++)
UniverseObjects[i].BehaviourController.UpdatePreDraw();
OnPreDraw?.InvokeSafe(this);
}
private void OnUniverseObjectFinalize(IInitializable initializable)
{
if (initializable is IUniverseObject universeObject)
Remove(universeObject);
}
private void OnUniverseObjectExitedUniverse(IUniverseObject sender, IUniverse universe)
{
if (sender is IUniverseObject universeObject)
Remove(universeObject);
}
public IEnumerator<IUniverseObject> GetEnumerator() => _universeObjects.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => _universeObjects.GetEnumerator();
}

66
Engine.Core/HierarchyObject.cs → Engine.Core/UniverseObject.cs
View File

@ -6,28 +6,28 @@ using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
[System.Diagnostics.DebuggerDisplay("Name: {Name}, Initialized: {Initialized}")]
public class HierarchyObject : BaseEntity, IHierarchyObject
public class UniverseObject : BaseEntity, IUniverseObject
{
public event IHierarchyObject.EnteredHierarchyEventHandler? OnEnteredHierarchy = null;
public event IHierarchyObject.ExitedHierarchyEventHandler? OnExitedHierarchy = null;
public event IHierarchyObject.ParentChangedEventHandler? OnParentChanged = null;
public event IHierarchyObject.ChildrenAddedEventHandler? OnChildrenAdded = null;
public event IHierarchyObject.ChildrenRemovedEventHandler? OnChildrenRemoved = null;
public event IUniverseObject.EnteredUniverseEventHandler? OnEnteredUniverse = null;
public event IUniverseObject.ExitedUniverseEventHandler? OnExitedUniverse = null;
public event IUniverseObject.ParentChangedEventHandler? OnParentChanged = null;
public event IUniverseObject.ChildrenAddedEventHandler? OnChildrenAdded = null;
public event IUniverseObject.ChildrenRemovedEventHandler? OnChildrenRemoved = null;
public event IHasBehaviourController.BehaviourControllerAssignedEventHandler? OnBehaviourControllerAssigned = null;
public event INameable.NameChangedEventHandler? OnNameChanged = null;
public event IActive.ActiveChangedEventHandler? OnActiveChanged = null;
private string _name = nameof(HierarchyObject);
private IGameManager _gameManager = null!;
private string _name = nameof(UniverseObject);
private IUniverse _universe = null!;
private IBehaviourController _behaviourController = null!;
private bool _isActive = false;
private readonly List<IHierarchyObject> _children = [];
private readonly List<IUniverseObject> _children = [];
public IHierarchyObject? Parent { get; private set; } = null;
public IReadOnlyList<IHierarchyObject> Children => _children;
public IUniverseObject? Parent { get; private set; } = null;
public IReadOnlyList<IUniverseObject> Children => _children;
public IBehaviourController BehaviourController => _behaviourController;
public IGameManager GameManager => _gameManager;
public bool IsInHierarchy => _gameManager is not null;
public IUniverse Universe => _universe;
public bool IsInUniverse => _universe is not null;
public bool IsActive => _isActive;
public string Name
@ -43,32 +43,32 @@ public class HierarchyObject : BaseEntity, IHierarchyObject
}
}
protected virtual void OnEnteringHierarchy(IGameManager gameManager) { }
bool IHierarchyObject.EnterHierarchy(IGameManager gameManager)
protected virtual void OnEnteringUniverse(IUniverse universe) { }
bool IUniverseObject.EnterUniverse(IUniverse universe)
{
if (IsInHierarchy)
if (IsInUniverse)
return false;
_gameManager = gameManager;
_universe = universe;
UpdateActive();
OnEnteringHierarchy(gameManager);
OnEnteredHierarchy?.InvokeSafe(this, gameManager);
OnEnteringUniverse(universe);
OnEnteredUniverse?.InvokeSafe(this, universe);
return true;
}
protected virtual void OnExitingHierarchy(IGameManager gameManager) { }
bool IHierarchyObject.ExitHierarchy()
protected virtual void OnExitingUniverse(IUniverse universe) { }
bool IUniverseObject.ExitUniverse()
{
if (!IsInHierarchy || _gameManager is not IGameManager gameManager)
if (!IsInUniverse || _universe is not IUniverse universe)
return false;
OnExitingHierarchy(gameManager);
_gameManager = null!;
OnExitedHierarchy?.InvokeSafe(this, gameManager);
OnExitingUniverse(universe);
_universe = null!;
OnExitedUniverse?.InvokeSafe(this, universe);
return true;
}
public void SetParent(IHierarchyObject? parent)
public void SetParent(IUniverseObject? parent)
{
if (parent == this)
throw new Exceptions.AssignFailedException($"{Name} can not parent itself");
@ -76,7 +76,7 @@ public class HierarchyObject : BaseEntity, IHierarchyObject
if (Parent == parent)
return;
IHierarchyObject? previousParent = Parent;
IUniverseObject? previousParent = Parent;
if (previousParent is not null)
{
previousParent.RemoveChild(this);
@ -87,8 +87,8 @@ public class HierarchyObject : BaseEntity, IHierarchyObject
if (parent is not null)
{
if (parent.IsInHierarchy && !IsInHierarchy)
parent.GameManager.Register(this);
if (parent.IsInUniverse && !IsInUniverse)
parent.Universe.Register(this);
parent.AddChild(this);
parent.OnActiveChanged += OnParentActiveChanged;
@ -98,7 +98,7 @@ public class HierarchyObject : BaseEntity, IHierarchyObject
OnParentChanged?.InvokeSafe(this, previousParent, parent);
}
public void AddChild(IHierarchyObject parent)
public void AddChild(IUniverseObject parent)
{
if (_children.Contains(parent))
return;
@ -108,7 +108,7 @@ public class HierarchyObject : BaseEntity, IHierarchyObject
OnChildrenAdded?.InvokeSafe(this, parent);
}
public void RemoveChild(IHierarchyObject child)
public void RemoveChild(IUniverseObject child)
{
if (!_children.Remove(child))
return;
@ -160,11 +160,11 @@ public class HierarchyObject : BaseEntity, IHierarchyObject
_behaviourController ??= Factory.BehaviourControllerFactory.Instantiate(this);
}
public HierarchyObject()
public UniverseObject()
{
_name = GetType().Name;
}
public IEnumerator<IHierarchyObject> GetEnumerator() => _children.GetEnumerator();
public IEnumerator<IUniverseObject> GetEnumerator() => _children.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => _children.GetEnumerator();
}

2
Engine.Core/EngineTime.cs → Engine.Core/UniverseTime.cs
View File

@ -2,7 +2,7 @@ using System;
namespace Syntriax.Engine.Core;
public readonly struct EngineTime(TimeSpan TimeSinceStart, TimeSpan TimeDelta)
public readonly struct UniverseTime(TimeSpan TimeSinceStart, TimeSpan TimeDelta)
{
public readonly TimeSpan TimeSinceStart = TimeSinceStart;
public readonly TimeSpan DeltaSpan = TimeDelta;

4
Engine.Physics2D/Collider2DBehaviourBase.cs
View File

@ -37,10 +37,10 @@ public abstract class Collider2DBehaviourBase : Behaviour2D, ICollider2D
Transform.OnPositionChanged += SetNeedsRecalculationFromPosition;
Transform.OnRotationChanged += SetNeedsRecalculationFromRotation;
Transform.OnScaleChanged += SetNeedsRecalculationFromScale;
HierarchyObject.OnParentChanged += UpdateRigidBody2D;
UniverseObject.OnParentChanged += UpdateRigidBody2D;
}
private void UpdateRigidBody2D(IHierarchyObject sender, IHierarchyObject? previousParent, IHierarchyObject? newParent)
private void UpdateRigidBody2D(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent)
{
BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
}

20
Engine.Physics2D/PhysicsCoroutineManager.cs
View File

@ -7,7 +7,7 @@ using Syntriax.Engine.Physics2D.Abstract;
namespace Syntriax.Engine.Physics2D;
public class PhysicsCoroutineManager : HierarchyObject
public class PhysicsCoroutineManager : UniverseObject
{
private readonly List<IEnumerator> enumerators = [];
private IPhysicsEngine2D? physicsEngine = null;
@ -23,13 +23,13 @@ public class PhysicsCoroutineManager : HierarchyObject
enumerators.Remove(enumerator);
}
protected override void OnEnteringHierarchy(IGameManager gameManager)
protected override void OnEnteringUniverse(IUniverse universe)
{
physicsEngine = gameManager.GetHierarchyObject<IPhysicsEngine2D>();
physicsEngine = universe.GetUniverseObject<IPhysicsEngine2D>();
if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
foundPhysicsEngine.OnPhysicsStep += OnPhysicsStep;
else
gameManager.OnUpdate += OnUpdate;
universe.OnUpdate += OnUpdate;
}
private void OnPhysicsStep(IPhysicsEngine2D sender, float stepDeltaTime)
@ -44,23 +44,23 @@ public class PhysicsCoroutineManager : HierarchyObject
}
}
protected override void OnExitingHierarchy(IGameManager gameManager)
protected override void OnExitingUniverse(IUniverse universe)
{
if (physicsEngine is IPhysicsEngine2D existingPhysicsEngine)
existingPhysicsEngine.OnPhysicsStep -= OnPhysicsStep;
gameManager.OnUpdate -= OnUpdate;
universe.OnUpdate -= OnUpdate;
}
private void OnUpdate(IGameManager sender, EngineTime engineTime)
private void OnUpdate(IUniverse sender, UniverseTime engineTime)
{
if (GameManager is not IGameManager gameManager)
if (Universe is not IUniverse universe)
return;
physicsEngine = gameManager.GetHierarchyObject<IPhysicsEngine2D>();
physicsEngine = universe.GetUniverseObject<IPhysicsEngine2D>();
if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
{
foundPhysicsEngine.OnPhysicsStep += OnPhysicsStep;
gameManager.OnUpdate -= OnUpdate;
universe.OnUpdate -= OnUpdate;
}
}
}

18
Engine.Physics2D/PhysicsEngine2D.cs
View File

@ -4,7 +4,7 @@ using Syntriax.Engine.Physics2D.Abstract;
namespace Syntriax.Engine.Physics2D;
public class PhysicsEngine2D : HierarchyObject, IPhysicsEngine2D
public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
{
public event IPhysicsEngine2D.PhysicsIterationEventHandler? OnPhysicsIteration = null;
public event IPhysicsEngine2D.PhysicsStepEventHandler? OnPhysicsStep = null;
@ -109,25 +109,25 @@ public class PhysicsEngine2D : HierarchyObject, IPhysicsEngine2D
rigidBody.Transform.Rotation += rigidBody.AngularVelocity * intervalDeltaTime;
}
protected override void OnEnteringHierarchy(IGameManager gameManager)
protected override void OnEnteringUniverse(IUniverse universe)
{
physicsUpdateCollector.Assign(gameManager);
colliderCollector.Assign(gameManager);
rigidBodyCollector.Assign(gameManager);
physicsUpdateCollector.Assign(universe);
colliderCollector.Assign(universe);
rigidBodyCollector.Assign(universe);
gameManager.OnPreUpdate += OnEnginePreUpdate;
universe.OnPreUpdate += OnEnginePreUpdate;
}
protected override void OnExitingHierarchy(IGameManager gameManager)
protected override void OnExitingUniverse(IUniverse universe)
{
physicsUpdateCollector.Unassign();
colliderCollector.Unassign();
rigidBodyCollector.Unassign();
gameManager.OnPreUpdate -= OnEnginePreUpdate;
universe.OnPreUpdate -= OnEnginePreUpdate;
}
private void OnEnginePreUpdate(IGameManager sender, EngineTime engineTime)
private void OnEnginePreUpdate(IUniverse sender, UniverseTime engineTime)
{
physicsTicker += engineTime.DeltaTime;

6
Engine.Systems/Time/StopwatchBehaviour.cs
View File

@ -44,13 +44,13 @@ public class StopwatchBehaviour : Behaviour, IStopwatch
if (State is not TimerState.Ticking)
return;
double delta = GameManager.Time.DeltaSpan.TotalSeconds;
double delta = Universe.Time.DeltaSpan.TotalSeconds;
Time += delta;
OnDelta?.InvokeSafe(this, delta);
}
protected override void OnEnteredHierarchy(IGameManager gameManager)
protected override void OnEnteredUniverse(IUniverse universe)
{
if (!shouldBeTicking || State is TimerState.Ticking)
return;
@ -61,7 +61,7 @@ public class StopwatchBehaviour : Behaviour, IStopwatch
StartStopwatch();
}
protected override void OnExitedHierarchy(IGameManager gameManager)
protected override void OnExitedUniverse(IUniverse universe)
{
if (!shouldBeTicking || State is not TimerState.Ticking)
return;

6
Engine.Systems/Time/TimerBehaviour.cs
View File

@ -59,7 +59,7 @@ public class TimerBehaviour : Behaviour, ITimer
if (State is not TimerState.Ticking)
return;
double delta = GameManager.Time.DeltaSpan.TotalSeconds;
double delta = Universe.Time.DeltaSpan.TotalSeconds;
Remaining -= delta;
OnDelta?.InvokeSafe(this, delta);
@ -68,7 +68,7 @@ public class TimerBehaviour : Behaviour, ITimer
Stop();
}
protected override void OnEnteredHierarchy(IGameManager gameManager)
protected override void OnEnteredUniverse(IUniverse universe)
{
if (!shouldBeTicking || State is TimerState.Ticking)
return;
@ -79,7 +79,7 @@ public class TimerBehaviour : Behaviour, ITimer
StartTimer();
}
protected override void OnExitedHierarchy(IGameManager gameManager)
protected override void OnExitedUniverse(IUniverse universe)
{
if (!shouldBeTicking || State is not TimerState.Ticking)
return;

10
Engine.Systems/Tween/TweenManager.cs
View File

@ -5,7 +5,7 @@ using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Systems.Tween;
public class TweenManager : HierarchyObject
public class TweenManager : UniverseObject
{
private CoroutineManager coroutineManager = null!;
@ -35,7 +35,7 @@ public class TweenManager : HierarchyObject
continue;
}
tween.Counter += GameManager.Time.DeltaTime;
tween.Counter += Universe.Time.DeltaTime;
yield return null;
}
@ -52,12 +52,12 @@ public class TweenManager : HierarchyObject
runningCoroutines.Remove(tween);
}
protected override void OnEnteringHierarchy(IGameManager gameManager)
protected override void OnEnteringUniverse(IUniverse universe)
{
coroutineManager = gameManager.GetRequiredHierarchyObject<CoroutineManager>();
coroutineManager = universe.GetRequiredUniverseObject<CoroutineManager>();
}
protected override void OnExitingHierarchy(IGameManager gameManager)
protected override void OnExitingUniverse(IUniverse universe)
{
coroutineManager = null!;
}