diff --git a/Engine.Core/Abstract/Assignable/IHasGameManager.cs b/Engine.Core/Abstract/Assignable/IHasGameManager.cs deleted file mode 100644 index 9946837..0000000 --- a/Engine.Core/Abstract/Assignable/IHasGameManager.cs +++ /dev/null @@ -1,26 +0,0 @@ -namespace Syntriax.Engine.Core.Abstract; - -/// -/// Indicates the object is an with an assignable field. -/// -public interface IHasGameManager : IAssignable -{ - /// - /// Event triggered when the value has has been assigned a new value. - /// - event GameManagerAssignedEventHandler? OnGameManagerAssigned; - - /// - IGameManager GameManager { get; } - - /// - /// Assign a value to the field of this object. - /// - /// New to assign. - /// - /// , if the value given assigned successfully assigned, if not. - /// - bool Assign(IGameManager gameManager); - - delegate void GameManagerAssignedEventHandler(IHasGameManager sender); -} diff --git a/Engine.Core/Abstract/Assignable/IHasHierarchyObject.cs b/Engine.Core/Abstract/Assignable/IHasHierarchyObject.cs deleted file mode 100644 index 6b7c6c9..0000000 --- a/Engine.Core/Abstract/Assignable/IHasHierarchyObject.cs +++ /dev/null @@ -1,26 +0,0 @@ -namespace Syntriax.Engine.Core.Abstract; - -/// -/// Indicates the object is an with an assignable field. -/// -public interface IHasHierarchyObject : IAssignable -{ - /// - /// Event triggered when the value has has been assigned a new value. - /// - event HierarchyObjectAssignedEventHandler? OnHierarchyObjectAssigned; - - /// - IHierarchyObject HierarchyObject { get; } - - /// - /// Assign a value to the field of this object. - /// - /// New to assign. - /// - /// , if the value given assigned successfully assigned, if not. - /// - bool Assign(IHierarchyObject hierarchyObject); - - delegate void HierarchyObjectAssignedEventHandler(IHasHierarchyObject sender); -} diff --git a/Engine.Core/Abstract/Assignable/IHasUniverse.cs b/Engine.Core/Abstract/Assignable/IHasUniverse.cs new file mode 100644 index 0000000..1a22111 --- /dev/null +++ b/Engine.Core/Abstract/Assignable/IHasUniverse.cs @@ -0,0 +1,26 @@ +namespace Syntriax.Engine.Core.Abstract; + +/// +/// Indicates the object is an with an assignable field. +/// +public interface IHasUniverse : IAssignable +{ + /// + /// Event triggered when the value has has been assigned a new value. + /// + event UniverseAssignedEventHandler? OnUniverseAssigned; + + /// + IUniverse Universe { get; } + + /// + /// Assign a value to the field of this object. + /// + /// New to assign. + /// + /// , if the value given assigned successfully assigned, if not. + /// + bool Assign(IUniverse universe); + + delegate void UniverseAssignedEventHandler(IHasUniverse sender); +} diff --git a/Engine.Core/Abstract/Assignable/IHasUniverseObject.cs b/Engine.Core/Abstract/Assignable/IHasUniverseObject.cs new file mode 100644 index 0000000..dcba13c --- /dev/null +++ b/Engine.Core/Abstract/Assignable/IHasUniverseObject.cs @@ -0,0 +1,26 @@ +namespace Syntriax.Engine.Core.Abstract; + +/// +/// Indicates the object is an with an assignable field. +/// +public interface IHasUniverseObject : IAssignable +{ + /// + /// Event triggered when the value has has been assigned a new value. + /// + event UniverseObjectAssignedEventHandler? OnUniverseObjectAssigned; + + /// + IUniverseObject UniverseObject { get; } + + /// + /// Assign a value to the field of this object. + /// + /// New to assign. + /// + /// , if the value given assigned successfully assigned, if not. + /// + bool Assign(IUniverseObject universeObject); + + delegate void UniverseObjectAssignedEventHandler(IHasUniverseObject sender); +} diff --git a/Engine.Core/Abstract/IBehaviour.cs b/Engine.Core/Abstract/IBehaviour.cs index 6858d0a..427b05b 100644 --- a/Engine.Core/Abstract/IBehaviour.cs +++ b/Engine.Core/Abstract/IBehaviour.cs @@ -1,7 +1,7 @@ namespace Syntriax.Engine.Core.Abstract; /// -/// 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. /// public interface IBehaviour : IEntity, IActive, IHasBehaviourController, IHasStateEnable { diff --git a/Engine.Core/Abstract/IBehaviourCollector.cs b/Engine.Core/Abstract/IBehaviourCollector.cs index a1d4527..06e9d4b 100644 --- a/Engine.Core/Abstract/IBehaviourCollector.cs +++ b/Engine.Core/Abstract/IBehaviourCollector.cs @@ -4,10 +4,10 @@ namespace Syntriax.Engine.Core.Abstract; /// /// Represents a collector for the class type of . -/// Provides mechanisms for tracking additions and removals, and notifies subscribers when such events occur on the assigned . +/// Provides mechanisms for tracking additions and removals, and notifies subscribers when such events occur on the assigned . /// /// The type of objects tracked by the collector. -public interface IBehaviourCollector : IHasGameManager, IEnumerable where T : class +public interface IBehaviourCollector : IHasUniverse, IEnumerable where T : class { /// /// Event triggered when an object of type is added to the collector. diff --git a/Engine.Core/Abstract/IBehaviourController.cs b/Engine.Core/Abstract/IBehaviourController.cs index 17e7e57..6e9b9a3 100644 --- a/Engine.Core/Abstract/IBehaviourController.cs +++ b/Engine.Core/Abstract/IBehaviourController.cs @@ -3,9 +3,9 @@ using System.Collections.Generic; namespace Syntriax.Engine.Core.Abstract; /// -/// Represents a controller for managing s and notify them accordingly about the engine's updates. Connected to an . +/// Represents a controller for managing s and notify them accordingly about the engine's updates. Connected to an . /// -public interface IBehaviourController : IInitializable, IHasHierarchyObject, IEnumerable +public interface IBehaviourController : IInitializable, IHasUniverseObject, IEnumerable { /// /// Event triggered before the update of s. diff --git a/Engine.Core/Abstract/IGameManager.cs b/Engine.Core/Abstract/IGameManager.cs deleted file mode 100644 index 19b52f7..0000000 --- a/Engine.Core/Abstract/IGameManager.cs +++ /dev/null @@ -1,91 +0,0 @@ -using System.Collections.Generic; - -namespace Syntriax.Engine.Core.Abstract; - -/// -/// Represents a game world responsible for managing s. -/// -public interface IGameManager : IEntity, IEnumerable -{ - /// - /// Event triggered when is about to be called called on the . - /// - event UpdateEventHandler? OnPreUpdate; - - /// - /// Event triggered when is called on the . - /// - event UpdateEventHandler? OnUpdate; - - /// - /// Event triggered when is called on the . - /// - event PreDrawEventHandler? OnPreDraw; - - /// - /// Event triggered when a is registered to the . - /// - event HierarchyObjectRegisteredEventHandler? OnHierarchyObjectRegistered; - - /// - /// Event triggered when a is unregistered from the . - /// - event HierarchyObjectUnRegisteredEventHandler? OnHierarchyObjectUnRegistered; - - /// - /// Current time scale the operates on. - /// - float TimeScale { get; set; } - - /// - /// Contains time data related to this . - /// - EngineTime Time { get; } - - /// - /// Contains unscaled time data related to this . - /// - EngineTime UnscaledTime { get; } - - /// - /// Gets a read-only list of s managed by the . - /// - IReadOnlyList HierarchyObjects { get; } - - /// - /// Registers an to the . - /// - /// The to register. - void Register(IHierarchyObject hierarchyObject); - - /// - /// Instantiates a of type T with the given arguments and registers it to the . - /// - /// The type of to instantiate. - /// Constructor parameters for the given type of . - /// The instantiated . - T InstantiateHierarchyObject(params object?[]? args) where T : class, IHierarchyObject; - - /// - /// Removes an from the . - /// - /// The to remove. - void Remove(IHierarchyObject hierarchyObject); - - /// - /// Updates the with the given delta time. - /// - /// Delta time. - void Update(EngineTime engineTime); - - /// - /// Performs operations that should be done before the draw calls. - /// - 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); -} diff --git a/Engine.Core/Abstract/IHierarchyObject.cs b/Engine.Core/Abstract/IHierarchyObject.cs deleted file mode 100644 index e3909b5..0000000 --- a/Engine.Core/Abstract/IHierarchyObject.cs +++ /dev/null @@ -1,131 +0,0 @@ -using System.Collections.Generic; - -namespace Syntriax.Engine.Core.Abstract; - -/// -/// Represents an that can enter and exit a hierarchy within the 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. -/// -public interface IHierarchyObject : IEntity, IActive, INameable, IHasBehaviourController, IEnumerable -{ - /// - /// Event triggered when the enters the hierarchy. - /// - event EnteredHierarchyEventHandler? OnEnteredHierarchy; - - /// - /// Event triggered when the exits the hierarchy. - /// - event ExitedHierarchyEventHandler? OnExitedHierarchy; - - /// - /// Event triggered when the of the changes. The second parameter is the old . - /// - event ParentChangedEventHandler? OnParentChanged; - - /// - /// Event triggered when a new is added to the . - /// - event ChildrenAddedEventHandler? OnChildrenAdded; - - /// - /// Event triggered when an is removed from the . - /// - event ChildrenRemovedEventHandler? OnChildrenRemoved; - - /// - /// Gets the this is connected to, if any. - /// - IGameManager GameManager { get; } - - /// - /// Indicates whether the is currently in the hierarchy. - /// - bool IsInHierarchy { get; } - - /// - /// The parent of the . - /// - IHierarchyObject? Parent { get; } - - /// - /// The s that have this as their . - /// - IReadOnlyList Children { get; } - - /// - /// Internal method to handle entering the hierarchy. - /// This should be called by the system to properly manage hierarchy states. - /// - /// The that is managing this hierarchy. - /// - /// if the successfully entered the hierarchy; - /// if it failed to do so. - /// - internal bool EnterHierarchy(IGameManager gameManager); - - /// - /// Internal method to handle exiting the hierarchy. - /// This should be called by the system to properly manage hierarchy states. - /// - /// - /// if the successfully exited the hierarchy; - /// if it failed to do so. - /// - internal bool ExitHierarchy(); - - /// - /// Sets the parent of this . - /// - /// The parent to set. - void SetParent(IHierarchyObject? hierarchyObject); - - /// - /// Adds a child to this . - /// - /// The child to add. - void AddChild(IHierarchyObject hierarchyObject); - - /// - /// Removes a child from this . - /// - /// The child to remove. - void RemoveChild(IHierarchyObject hierarchyObject); - - /// - /// EventHandler delegate for the event triggered when the enters the hierarchy of a . - /// - /// The that entered the hierarchy. - /// The that the has entered it's hierarchy. - delegate void EnteredHierarchyEventHandler(IHierarchyObject sender, IGameManager gameManager); - - /// - /// EventHandler delegate for the event triggered when the exits the hierarchy of a . - /// - /// The that exited the hierarchy. - /// The that the has exited it's hierarchy. - delegate void ExitedHierarchyEventHandler(IHierarchyObject sender, IGameManager gameManager); - - /// - /// Delegate for the event triggered when the 's parent changes. - /// - /// The that the parent has changed. - /// The previous the sender was a child of. - /// The new and current the sender is a child of. - delegate void ParentChangedEventHandler(IHierarchyObject sender, IHierarchyObject? previousParent, IHierarchyObject? newParent); - - /// - /// Delegate for the event triggered when a new added as a child. - /// - /// The parent this event is being called from. - /// The that got removed as a children of the sender . - delegate void ChildrenAddedEventHandler(IHierarchyObject sender, IHierarchyObject childrenAdded); - - /// - /// Delegate for the event triggered when a new removed from being a child. - /// - /// The parent this event is being called from. - /// The that got removed as a children of the sender . - delegate void ChildrenRemovedEventHandler(IHierarchyObject sender, IHierarchyObject childrenRemoved); -} diff --git a/Engine.Core/Abstract/IUniverse.cs b/Engine.Core/Abstract/IUniverse.cs new file mode 100644 index 0000000..99017c2 --- /dev/null +++ b/Engine.Core/Abstract/IUniverse.cs @@ -0,0 +1,91 @@ +using System.Collections.Generic; + +namespace Syntriax.Engine.Core.Abstract; + +/// +/// Represents a universe responsible for managing s. +/// +public interface IUniverse : IEntity, IEnumerable +{ + /// + /// Event triggered when is about to be called called on the . + /// + event UpdateEventHandler? OnPreUpdate; + + /// + /// Event triggered when is called on the . + /// + event UpdateEventHandler? OnUpdate; + + /// + /// Event triggered when is called on the . + /// + event PreDrawEventHandler? OnPreDraw; + + /// + /// Event triggered when a is registered to the . + /// + event UniverseObjectRegisteredEventHandler? OnUniverseObjectRegistered; + + /// + /// Event triggered when a is unregistered from the . + /// + event UniverseObjectUnRegisteredEventHandler? OnUniverseObjectUnRegistered; + + /// + /// Current time scale the operates on. + /// + float TimeScale { get; set; } + + /// + /// Contains time data related to this . + /// + UniverseTime Time { get; } + + /// + /// Contains unscaled time data related to this . + /// + UniverseTime UnscaledTime { get; } + + /// + /// Gets a read-only list of s managed by the . + /// + IReadOnlyList UniverseObjects { get; } + + /// + /// Registers an to the . + /// + /// The to register. + void Register(IUniverseObject universeObject); + + /// + /// Instantiates a of type T with the given arguments and registers it to the . + /// + /// The type of to instantiate. + /// Constructor parameters for the given type of . + /// The instantiated . + T InstantiateUniverseObject(params object?[]? args) where T : class, IUniverseObject; + + /// + /// Removes an from the . + /// + /// The to remove. + void Remove(IUniverseObject universeObject); + + /// + /// Updates the with the given delta time. + /// + /// Delta time. + void Update(UniverseTime universeTime); + + /// + /// Performs operations that should be done before the draw calls. + /// + 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); +} diff --git a/Engine.Core/Abstract/IUniverseObject.cs b/Engine.Core/Abstract/IUniverseObject.cs new file mode 100644 index 0000000..4fa2f28 --- /dev/null +++ b/Engine.Core/Abstract/IUniverseObject.cs @@ -0,0 +1,131 @@ +using System.Collections.Generic; + +namespace Syntriax.Engine.Core.Abstract; + +/// +/// Represents an that can enter and exit a universe within the 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. +/// +public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourController, IEnumerable +{ + /// + /// Event triggered when the enters the universe. + /// + event EnteredUniverseEventHandler? OnEnteredUniverse; + + /// + /// Event triggered when the exits the universe. + /// + event ExitedUniverseEventHandler? OnExitedUniverse; + + /// + /// Event triggered when the of the changes. The second parameter is the old . + /// + event ParentChangedEventHandler? OnParentChanged; + + /// + /// Event triggered when a new is added to the . + /// + event ChildrenAddedEventHandler? OnChildrenAdded; + + /// + /// Event triggered when an is removed from the . + /// + event ChildrenRemovedEventHandler? OnChildrenRemoved; + + /// + /// Gets the this is connected to, if any. + /// + IUniverse Universe { get; } + + /// + /// Indicates whether the is currently in the universe. + /// + bool IsInUniverse { get; } + + /// + /// The parent of the . + /// + IUniverseObject? Parent { get; } + + /// + /// The s that have this as their . + /// + IReadOnlyList Children { get; } + + /// + /// Internal method to handle entering the universe. + /// This should be called by the system to properly manage universe states. + /// + /// The that is managing this universe. + /// + /// if the successfully entered the universe; + /// if it failed to do so. + /// + internal bool EnterUniverse(IUniverse universe); + + /// + /// Internal method to handle exiting the universe. + /// This should be called by the system to properly manage universe states. + /// + /// + /// if the successfully exited the universe; + /// if it failed to do so. + /// + internal bool ExitUniverse(); + + /// + /// Sets the parent of this . + /// + /// The parent to set. + void SetParent(IUniverseObject? universeObject); + + /// + /// Adds a child to this . + /// + /// The child to add. + void AddChild(IUniverseObject universeObject); + + /// + /// Removes a child from this . + /// + /// The child to remove. + void RemoveChild(IUniverseObject universeObject); + + /// + /// EventHandler delegate for the event triggered when the enters the universe of a . + /// + /// The that entered the universe. + /// The that the has entered it's universe. + delegate void EnteredUniverseEventHandler(IUniverseObject sender, IUniverse universe); + + /// + /// EventHandler delegate for the event triggered when the exits the universe of a . + /// + /// The that exited the universe. + /// The that the has exited it's universe. + delegate void ExitedUniverseEventHandler(IUniverseObject sender, IUniverse universe); + + /// + /// Delegate for the event triggered when the 's parent changes. + /// + /// The that the parent has changed. + /// The previous the sender was a child of. + /// The new and current the sender is a child of. + delegate void ParentChangedEventHandler(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent); + + /// + /// Delegate for the event triggered when a new added as a child. + /// + /// The parent this event is being called from. + /// The that got removed as a children of the sender . + delegate void ChildrenAddedEventHandler(IUniverseObject sender, IUniverseObject childrenAdded); + + /// + /// Delegate for the event triggered when a new removed from being a child. + /// + /// The parent this event is being called from. + /// The that got removed as a children of the sender . + delegate void ChildrenRemovedEventHandler(IUniverseObject sender, IUniverseObject childrenRemoved); +} diff --git a/Engine.Core/ActiveBehaviourCollector.cs b/Engine.Core/ActiveBehaviourCollector.cs index cb894b8..b2db768 100644 --- a/Engine.Core/ActiveBehaviourCollector.cs +++ b/Engine.Core/ActiveBehaviourCollector.cs @@ -9,7 +9,7 @@ namespace Syntriax.Engine.Core; public class ActiveBehaviourCollector : IBehaviourCollector 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.CollectedEventHandler? OnCollected = null; public event IBehaviourCollector.RemovedEventHandler? OnRemoved = null; @@ -19,29 +19,29 @@ public class ActiveBehaviourCollector : IBehaviourCollector where T : clas protected readonly Dictionary monitoringActiveToBehaviour = new(32); public IReadOnlyList 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 : IBehaviourCollector 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; } diff --git a/Engine.Core/ActiveBehaviourCollectorSorted.cs b/Engine.Core/ActiveBehaviourCollectorSorted.cs index 4918c2a..f10fb9d 100644 --- a/Engine.Core/ActiveBehaviourCollectorSorted.cs +++ b/Engine.Core/ActiveBehaviourCollectorSorted.cs @@ -26,5 +26,5 @@ public class ActiveBehaviourCollectorSorted : ActiveBehaviourCollector whe } public ActiveBehaviourCollectorSorted() { } - public ActiveBehaviourCollectorSorted(IGameManager gameManager, Comparison sortBy) : base(gameManager) => SortBy = sortBy; + public ActiveBehaviourCollectorSorted(IUniverse universe, Comparison sortBy) : base(universe) => SortBy = sortBy; } diff --git a/Engine.Core/Behaviour.cs b/Engine.Core/Behaviour.cs index c528d8b..fb33586 100644 --- a/Engine.Core/Behaviour.cs +++ b/Engine.Core/Behaviour.cs @@ -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); } diff --git a/Engine.Core/Behaviour2D.cs b/Engine.Core/Behaviour2D.cs index deadeee..e922fad 100644 --- a/Engine.Core/Behaviour2D.cs +++ b/Engine.Core/Behaviour2D.cs @@ -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); } diff --git a/Engine.Core/BehaviourBase.cs b/Engine.Core/BehaviourBase.cs index a3d18e0..8bb7bd2 100644 --- a/Engine.Core/BehaviourBase.cs +++ b/Engine.Core/BehaviourBase.cs @@ -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); diff --git a/Engine.Core/BehaviourCollector.cs b/Engine.Core/BehaviourCollector.cs index 46f1be4..a6be922 100644 --- a/Engine.Core/BehaviourCollector.cs +++ b/Engine.Core/BehaviourCollector.cs @@ -9,7 +9,7 @@ namespace Syntriax.Engine.Core; public class BehaviourCollector : IBehaviourCollector where T : class { public event IAssignable.UnassignEventHandler? OnUnassigned = null; - public event IHasGameManager.GameManagerAssignedEventHandler? OnGameManagerAssigned = null; + public event IHasUniverse.UniverseAssignedEventHandler? OnUniverseAssigned = null; public event IBehaviourCollector.CollectedEventHandler? OnCollected = null; public event IBehaviourCollector.RemovedEventHandler? OnRemoved = null; @@ -17,29 +17,29 @@ public class BehaviourCollector : IBehaviourCollector where T : class protected readonly List behaviours = new(32); public IReadOnlyList 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 : IBehaviourCollector 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; } diff --git a/Engine.Core/BehaviourCollectorSorted.cs b/Engine.Core/BehaviourCollectorSorted.cs index e96ab95..b1211c8 100644 --- a/Engine.Core/BehaviourCollectorSorted.cs +++ b/Engine.Core/BehaviourCollectorSorted.cs @@ -26,5 +26,5 @@ public class BehaviourCollectorSorted : BehaviourCollector where T : class } public BehaviourCollectorSorted() { } - public BehaviourCollectorSorted(IGameManager gameManager, Comparison sortBy) : base(gameManager) => SortBy = sortBy; + public BehaviourCollectorSorted(IUniverse universe, Comparison sortBy) : base(universe) => SortBy = sortBy; } diff --git a/Engine.Core/BehaviourController.cs b/Engine.Core/BehaviourController.cs index 85ac6a5..1f474f5 100644 --- a/Engine.Core/BehaviourController.cs +++ b/Engine.Core/BehaviourController.cs @@ -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 behaviours = new List(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(params object?[]? args) where T : class, IBehaviour - => AddBehaviour(Factory.BehaviourFactory.Instantiate(_hierarchyObject, args)); + => AddBehaviour(Factory.BehaviourFactory.Instantiate(_universeObject, args)); public T? GetBehaviour() { @@ -115,7 +115,7 @@ public class BehaviourController : IBehaviourController public void RemoveBehaviour(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 behaviour) where T : class, IBehaviour { diff --git a/Engine.Core/CoroutineManager.cs b/Engine.Core/CoroutineManager.cs index b6d54c4..8b9e498 100644 --- a/Engine.Core/CoroutineManager.cs +++ b/Engine.Core/CoroutineManager.cs @@ -5,7 +5,7 @@ using Syntriax.Engine.Core.Abstract; namespace Syntriax.Engine.Core; -public class CoroutineManager : HierarchyObject +public class CoroutineManager : UniverseObject { private readonly List 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--) { diff --git a/Engine.Core/Engine.Core.puml b/Engine.Core/Engine.Core.puml index f38813a..70fba87 100644 --- a/Engine.Core/Engine.Core.puml +++ b/Engine.Core/Engine.Core.puml @@ -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 ' } diff --git a/Engine.Core/Exceptions/HierarchyObjectNotFoundException.cs b/Engine.Core/Exceptions/HierarchyObjectNotFoundException.cs deleted file mode 100644 index c7161bd..0000000 --- a/Engine.Core/Exceptions/HierarchyObjectNotFoundException.cs +++ /dev/null @@ -1,9 +0,0 @@ -using System; - -namespace Syntriax.Engine.Core.Exceptions; - -public class HierarchyObjectNotFoundException(string? message) : Exception(message) -{ - public static NotAssignedException FromType() - => new($"{typeof(THierarchyObject).FullName} was not found"); -} diff --git a/Engine.Core/Exceptions/UniverseObjectNotFoundException.cs b/Engine.Core/Exceptions/UniverseObjectNotFoundException.cs new file mode 100644 index 0000000..b49d848 --- /dev/null +++ b/Engine.Core/Exceptions/UniverseObjectNotFoundException.cs @@ -0,0 +1,9 @@ +using System; + +namespace Syntriax.Engine.Core.Exceptions; + +public class UniverseObjectNotFoundException(string? message) : Exception(message) +{ + public static NotAssignedException FromType() + => new($"{typeof(TUniverseObject).FullName} was not found"); +} diff --git a/Engine.Core/Extensions/BehaviourControllerExtensions.cs b/Engine.Core/Extensions/BehaviourControllerExtensions.cs index 58014b1..9449283 100644 --- a/Engine.Core/Extensions/BehaviourControllerExtensions.cs +++ b/Engine.Core/Extensions/BehaviourControllerExtensions.cs @@ -27,7 +27,7 @@ public static class BehaviourControllerExtensions /// The to start searching from. /// The of the specified type if found; otherwise, throws . public static T GetRequiredBehaviour(this IBehaviourController behaviourController) where T : class - => behaviourController.GetBehaviour() ?? throw new BehaviourNotFoundException($"{behaviourController.HierarchyObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName}"); + => behaviourController.GetBehaviour() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName}"); /// /// Gets an existing 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() ?? behaviourController.AddBehaviour(args); /// - /// Tries to get a of the specified type in it's 's parents recursively. + /// Tries to get a of the specified type in it's 's parents recursively. /// /// The type of to get. /// The to start searching from. /// When this method returns, contains the of the specified type, if found; otherwise, null. - /// if a of the specified type was found in the parent hierarchy; otherwise, . + /// if a of the specified type was found in the parent universe; otherwise, . public static bool TryGetBehaviourInParent(this IBehaviourController behaviourController, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class { behaviour = GetBehaviourInParent(behaviourController); @@ -53,7 +53,7 @@ public static class BehaviourControllerExtensions } /// - /// Gets a of the specified type in it's 's parents recursively. + /// Gets a of the specified type in it's 's parents recursively. /// /// The type of to get. /// The to start searching from. @@ -67,28 +67,28 @@ public static class BehaviourControllerExtensions if (controller.GetBehaviour() is T behaviour) return behaviour; - controller = controller.HierarchyObject.Parent?.BehaviourController; + controller = controller.UniverseObject.Parent?.BehaviourController; } return default; } /// - /// Gets a of the specified type in it's 's parents recursively. Throws an error if not found. + /// Gets a of the specified type in it's 's parents recursively. Throws an error if not found. /// /// The type of to get. /// The to start searching from. /// The of the specified type if found; otherwise, throws . public static T GetRequiredBehaviourInParent(this IBehaviourController behaviourController) where T : class - => behaviourController.GetBehaviourInParent() ?? throw new BehaviourNotFoundException($"{behaviourController.HierarchyObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any parent"); + => behaviourController.GetBehaviourInParent() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any parent"); /// - /// Tries to get a of the specified type in it's 's children recursively. + /// Tries to get a of the specified type in it's 's children recursively. /// /// The type of to get. /// The to start searching from. /// When this method returns, contains the of the specified type, if found; otherwise, null. - /// if a of the specified type was found in the child hierarchy; otherwise, . + /// if a of the specified type was found in the child universe; otherwise, . public static bool TryGetBehaviourInChildren(this IBehaviourController behaviourController, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class { behaviour = GetBehaviourInChildren(behaviourController); @@ -96,7 +96,7 @@ public static class BehaviourControllerExtensions } /// - /// Gets a of the specified type in it's 's children recursively. + /// Gets a of the specified type in it's 's children recursively. /// /// The type of to get. /// The to start searching from. @@ -106,7 +106,7 @@ public static class BehaviourControllerExtensions if (behaviourController.GetBehaviour() is T localBehaviour) return localBehaviour; - foreach (IHierarchyObject child in behaviourController.HierarchyObject) + foreach (IUniverseObject child in behaviourController.UniverseObject) if (GetBehaviourInChildren(child.BehaviourController) is T behaviour) return behaviour; @@ -120,5 +120,5 @@ public static class BehaviourControllerExtensions /// The to start searching from. /// The of the specified type if found; otherwise, throws . public static T GetRequiredBehaviourInChildren(this IBehaviourController behaviourController) where T : class - => behaviourController.GetBehaviourInChildren() ?? throw new BehaviourNotFoundException($"{behaviourController.HierarchyObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any children "); + => behaviourController.GetBehaviourInChildren() ?? throw new BehaviourNotFoundException($"{behaviourController.UniverseObject.Name}'s {nameof(IBehaviourController)} does not contain any {typeof(T).FullName} on any children "); } diff --git a/Engine.Core/Extensions/BehaviourExtensions.cs b/Engine.Core/Extensions/BehaviourExtensions.cs index 7f28340..8136c30 100644 --- a/Engine.Core/Extensions/BehaviourExtensions.cs +++ b/Engine.Core/Extensions/BehaviourExtensions.cs @@ -7,29 +7,29 @@ namespace Syntriax.Engine.Core; public static class BehaviourExtensions { - public static T? FindBehaviour(this IEnumerable hierarchyObjects) where T : class + public static T? FindBehaviour(this IEnumerable universeObjects) where T : class { - foreach (IHierarchyObject hierarchyObject in hierarchyObjects) - if (hierarchyObject.BehaviourController.GetBehaviour() is T behaviour) + foreach (IUniverseObject universeObject in universeObjects) + if (universeObject.BehaviourController.GetBehaviour() is T behaviour) return behaviour; return default; } - public static bool TryFindBehaviour(this IEnumerable hierarchyObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class + public static bool TryFindBehaviour(this IEnumerable universeObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class { - behaviour = FindBehaviour(hierarchyObjects); + behaviour = FindBehaviour(universeObjects); return behaviour is not null; } - public static void FindBehaviours(this IEnumerable hierarchyObjects, List behaviours) where T : class + public static void FindBehaviours(this IEnumerable universeObjects, List behaviours) where T : class { behaviours.Clear(); List cache = []; - foreach (IHierarchyObject hierarchyObject in hierarchyObjects) + foreach (IUniverseObject universeObject in universeObjects) { - hierarchyObject.BehaviourController.GetBehaviours(cache); + universeObject.BehaviourController.GetBehaviours(cache); behaviours.AddRange(cache); } } diff --git a/Engine.Core/Extensions/GameManagerExtensions.cs b/Engine.Core/Extensions/GameManagerExtensions.cs deleted file mode 100644 index db991e6..0000000 --- a/Engine.Core/Extensions/GameManagerExtensions.cs +++ /dev/null @@ -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(args); - - public static T GetRequiredHierarchyObject(this IGameManager gameManager) where T : class - => gameManager.GetHierarchyObject() ?? throw new HierarchyObjectNotFoundException($"{gameManager.GetType().FullName}({gameManager.Id}) does not contain any {nameof(IHierarchyObject)} object of type {typeof(T).FullName}"); - - public static T FindRequiredBehaviour(this IGameManager gameManager) where T : class - => gameManager.FindBehaviour() ?? throw new BehaviourNotFoundException($"{gameManager.GetType().FullName}({gameManager.Id}) does not contain any {nameof(IHierarchyObject)} with {nameof(IBehaviour)} of type {typeof(T).FullName}"); -} diff --git a/Engine.Core/Extensions/HierarchyObjectExtensions.cs b/Engine.Core/Extensions/HierarchyObjectExtensions.cs deleted file mode 100644 index 1f2a73e..0000000 --- a/Engine.Core/Extensions/HierarchyObjectExtensions.cs +++ /dev/null @@ -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(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(this IEnumerable hierarchyObjects) where T : class - { - foreach (IHierarchyObject hierarchyObject in hierarchyObjects) - if (hierarchyObject is T @object) - return @object; - - return default; - } - - public static bool TryGetHierarchyObject(this IEnumerable hierarchyObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class - { - behaviour = GetHierarchyObject(hierarchyObjects); - return behaviour is not null; - } - - public static void GetHierarchyObjects(this IEnumerable hierarchyObjects, List behaviours) where T : class - { - behaviours.Clear(); - foreach (IHierarchyObject hierarchyObject in hierarchyObjects) - if (hierarchyObject is T @object) - behaviours.Add(@object); - } -} diff --git a/Engine.Core/Extensions/UniverseExtensions.cs b/Engine.Core/Extensions/UniverseExtensions.cs new file mode 100644 index 0000000..64f6589 --- /dev/null +++ b/Engine.Core/Extensions/UniverseExtensions.cs @@ -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(args); + + public static T GetRequiredUniverseObject(this IUniverse universe) where T : class + => universe.GetUniverseObject() ?? throw new UniverseObjectNotFoundException($"{universe.GetType().FullName}({universe.Id}) does not contain any {nameof(IUniverseObject)} object of type {typeof(T).FullName}"); + + public static T FindRequiredBehaviour(this IUniverse universe) where T : class + => universe.FindBehaviour() ?? throw new BehaviourNotFoundException($"{universe.GetType().FullName}({universe.Id}) does not contain any {nameof(IUniverseObject)} with {nameof(IBehaviour)} of type {typeof(T).FullName}"); +} diff --git a/Engine.Core/Extensions/UniverseObjectExtensions.cs b/Engine.Core/Extensions/UniverseObjectExtensions.cs new file mode 100644 index 0000000..52a01a3 --- /dev/null +++ b/Engine.Core/Extensions/UniverseObjectExtensions.cs @@ -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(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(this IEnumerable universeObjects) where T : class + { + foreach (IUniverseObject universeObject in universeObjects) + if (universeObject is T @object) + return @object; + + return default; + } + + public static bool TryGetUniverseObject(this IEnumerable universeObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class + { + behaviour = GetUniverseObject(universeObjects); + return behaviour is not null; + } + + public static void GetUniverseObjects(this IEnumerable universeObjects, List behaviours) where T : class + { + behaviours.Clear(); + foreach (IUniverseObject universeObject in universeObjects) + if (universeObject is T @object) + behaviours.Add(@object); + } +} diff --git a/Engine.Core/Factory/BehaviourControllerFactory.cs b/Engine.Core/Factory/BehaviourControllerFactory.cs index 587a96d..b01ea74 100644 --- a/Engine.Core/Factory/BehaviourControllerFactory.cs +++ b/Engine.Core/Factory/BehaviourControllerFactory.cs @@ -5,19 +5,19 @@ namespace Syntriax.Engine.Core.Factory; public class BehaviourControllerFactory { - public static IBehaviourController Instantiate(IHierarchyObject hierarchyObject) - => Instantiate(hierarchyObject); + public static IBehaviourController Instantiate(IUniverseObject universeObject) + => Instantiate(universeObject); - public static T Instantiate(IHierarchyObject hierarchyObject, params object?[]? args) + public static T Instantiate(IUniverseObject universeObject, params object?[]? args) where T : class, IBehaviourController { T behaviourController = TypeFactory.Get(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; } diff --git a/Engine.Core/Factory/BehaviourFactory.cs b/Engine.Core/Factory/BehaviourFactory.cs index 6a832e9..87251e4 100644 --- a/Engine.Core/Factory/BehaviourFactory.cs +++ b/Engine.Core/Factory/BehaviourFactory.cs @@ -5,10 +5,10 @@ namespace Syntriax.Engine.Core.Factory; public class BehaviourFactory { - public static T Instantiate(IHierarchyObject hierarchyObject, params object?[]? args) where T : class, IBehaviour - => Instantiate(hierarchyObject, stateEnable: null, args); + public static T Instantiate(IUniverseObject universeObject, params object?[]? args) where T : class, IBehaviour + => Instantiate(universeObject, stateEnable: null, args); - public static T Instantiate(IHierarchyObject hierarchyObject, IStateEnable? stateEnable, params object?[]? args) + public static T Instantiate(IUniverseObject universeObject, IStateEnable? stateEnable, params object?[]? args) where T : class, IBehaviour { T behaviour = TypeFactory.Get(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; } diff --git a/Engine.Core/Factory/HierarchyObjectFactory.cs b/Engine.Core/Factory/HierarchyObjectFactory.cs deleted file mode 100644 index 23ec301..0000000 --- a/Engine.Core/Factory/HierarchyObjectFactory.cs +++ /dev/null @@ -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(); - public static T Instantiate(params object?[]? args) where T : class, IHierarchyObject - => Instantiate(behaviourController: null, stateEnable: null, args); - - public static IHierarchyObject Instantiate(IBehaviourController? behaviourController = null, IStateEnable? stateEnable = null) => Instantiate(behaviourController, stateEnable); - public static T Instantiate( - IBehaviourController? behaviourController = null, - IStateEnable? stateEnable = null, - params object?[]? args - ) - where T : class, IHierarchyObject - { - T hierarchyObject = TypeFactory.Get(args); - - behaviourController ??= TypeFactory.Get(); - stateEnable ??= TypeFactory.Get(); - - 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; - } -} diff --git a/Engine.Core/Factory/UniverseObjectFactory.cs b/Engine.Core/Factory/UniverseObjectFactory.cs new file mode 100644 index 0000000..7052574 --- /dev/null +++ b/Engine.Core/Factory/UniverseObjectFactory.cs @@ -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(); + public static T Instantiate(params object?[]? args) where T : class, IUniverseObject + => Instantiate(behaviourController: null, stateEnable: null, args); + + public static IUniverseObject Instantiate(IBehaviourController? behaviourController = null, IStateEnable? stateEnable = null) => Instantiate(behaviourController, stateEnable); + public static T Instantiate( + IBehaviourController? behaviourController = null, + IStateEnable? stateEnable = null, + params object?[]? args + ) + where T : class, IUniverseObject + { + T universeObject = TypeFactory.Get(args); + + behaviourController ??= TypeFactory.Get(); + stateEnable ??= TypeFactory.Get(); + + 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; + } +} diff --git a/Engine.Core/GameManager.cs b/Engine.Core/GameManager.cs deleted file mode 100644 index 9fc6b81..0000000 --- a/Engine.Core/GameManager.cs +++ /dev/null @@ -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 _hierarchyObjects = new(Constants.GAME_OBJECTS_SIZE_INITIAL); - private float _timeScale = 1f; - - public IReadOnlyList 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(params object?[]? args) where T : class, IHierarchyObject - { - T hierarchyObject = Factory.HierarchyObjectFactory.Instantiate(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 GetEnumerator() => _hierarchyObjects.GetEnumerator(); - IEnumerator IEnumerable.GetEnumerator() => _hierarchyObjects.GetEnumerator(); -} diff --git a/Engine.Core/Helpers/AssertHelpers.cs b/Engine.Core/Helpers/AssertHelpers.cs index f01a167..12adf03 100644 --- a/Engine.Core/Helpers/AssertHelpers.cs +++ b/Engine.Core/Helpers/AssertHelpers.cs @@ -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) diff --git a/Engine.Core/Static/Internal/Constants.cs b/Engine.Core/Static/Internal/Constants.cs index 30273e4..535e17d 100644 --- a/Engine.Core/Static/Internal/Constants.cs +++ b/Engine.Core/Static/Internal/Constants.cs @@ -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; } diff --git a/Engine.Core/Transform2D.cs b/Engine.Core/Transform2D.cs index a5ebb46..c178dcb 100644 --- a/Engine.Core/Transform2D.cs +++ b/Engine.Core/Transform2D.cs @@ -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); } diff --git a/Engine.Core/Universe.cs b/Engine.Core/Universe.cs new file mode 100644 index 0000000..38b74fe --- /dev/null +++ b/Engine.Core/Universe.cs @@ -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 _universeObjects = new(Constants.UNIVERSE_OBJECTS_SIZE_INITIAL); + private float _timeScale = 1f; + + public IReadOnlyList 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(params object?[]? args) where T : class, IUniverseObject + { + T universeObject = Factory.UniverseObjectFactory.Instantiate(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 GetEnumerator() => _universeObjects.GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => _universeObjects.GetEnumerator(); +} diff --git a/Engine.Core/HierarchyObject.cs b/Engine.Core/UniverseObject.cs similarity index 64% rename from Engine.Core/HierarchyObject.cs rename to Engine.Core/UniverseObject.cs index 5d75a03..a84e03a 100644 --- a/Engine.Core/HierarchyObject.cs +++ b/Engine.Core/UniverseObject.cs @@ -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 _children = []; + private readonly List _children = []; - public IHierarchyObject? Parent { get; private set; } = null; - public IReadOnlyList Children => _children; + public IUniverseObject? Parent { get; private set; } = null; + public IReadOnlyList 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 GetEnumerator() => _children.GetEnumerator(); + public IEnumerator GetEnumerator() => _children.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => _children.GetEnumerator(); } diff --git a/Engine.Core/EngineTime.cs b/Engine.Core/UniverseTime.cs similarity index 74% rename from Engine.Core/EngineTime.cs rename to Engine.Core/UniverseTime.cs index d54964c..ed73de7 100644 --- a/Engine.Core/EngineTime.cs +++ b/Engine.Core/UniverseTime.cs @@ -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; diff --git a/Engine.Physics2D/Collider2DBehaviourBase.cs b/Engine.Physics2D/Collider2DBehaviourBase.cs index 7bd8384..9dae58c 100644 --- a/Engine.Physics2D/Collider2DBehaviourBase.cs +++ b/Engine.Physics2D/Collider2DBehaviourBase.cs @@ -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); } diff --git a/Engine.Physics2D/PhysicsCoroutineManager.cs b/Engine.Physics2D/PhysicsCoroutineManager.cs index 62feb2f..b480e31 100644 --- a/Engine.Physics2D/PhysicsCoroutineManager.cs +++ b/Engine.Physics2D/PhysicsCoroutineManager.cs @@ -7,7 +7,7 @@ using Syntriax.Engine.Physics2D.Abstract; namespace Syntriax.Engine.Physics2D; -public class PhysicsCoroutineManager : HierarchyObject +public class PhysicsCoroutineManager : UniverseObject { private readonly List 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(); + physicsEngine = universe.GetUniverseObject(); 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(); + physicsEngine = universe.GetUniverseObject(); if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine) { foundPhysicsEngine.OnPhysicsStep += OnPhysicsStep; - gameManager.OnUpdate -= OnUpdate; + universe.OnUpdate -= OnUpdate; } } } diff --git a/Engine.Physics2D/PhysicsEngine2D.cs b/Engine.Physics2D/PhysicsEngine2D.cs index d823277..6b50627 100644 --- a/Engine.Physics2D/PhysicsEngine2D.cs +++ b/Engine.Physics2D/PhysicsEngine2D.cs @@ -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; diff --git a/Engine.Systems/Time/StopwatchBehaviour.cs b/Engine.Systems/Time/StopwatchBehaviour.cs index 1905ac6..98a5a8d 100644 --- a/Engine.Systems/Time/StopwatchBehaviour.cs +++ b/Engine.Systems/Time/StopwatchBehaviour.cs @@ -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; diff --git a/Engine.Systems/Time/TimerBehaviour.cs b/Engine.Systems/Time/TimerBehaviour.cs index df83629..6c7cbd2 100644 --- a/Engine.Systems/Time/TimerBehaviour.cs +++ b/Engine.Systems/Time/TimerBehaviour.cs @@ -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; diff --git a/Engine.Systems/Tween/TweenManager.cs b/Engine.Systems/Tween/TweenManager.cs index 5ec7fdd..f7758c4 100644 --- a/Engine.Systems/Tween/TweenManager.cs +++ b/Engine.Systems/Tween/TweenManager.cs @@ -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 = universe.GetRequiredUniverseObject(); } - protected override void OnExitingHierarchy(IGameManager gameManager) + protected override void OnExitingUniverse(IUniverse universe) { coroutineManager = null!; }