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

Compare commits

base: Syntriax:development
Branches Tags
Syntriax:main
Syntriax:development
Syntriax:feat/hierarchy
Syntriax:feat/gameobject-serialization
Syntriax:feat/physics2d
Syntriax:breaking-change/demonogame
..
compare: Syntriax:main
Branches Tags
Syntriax:development
Syntriax:feat/hierarchy
Syntriax:feat/gameobject-serialization
Syntriax:main
Syntriax:feat/physics2d
Syntriax:breaking-change/demonogame

No commits in common. "development" and "main" have entirely different histories.
developmen ... main

54 changed files with 408 additions and 1457 deletions
Show Stats Expand all files Collapse all files

6
Engine.Core/Abstract/Assignable/IAssignable.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,7 +10,7 @@ public interface IAssignable
/// <summary>
/// Event triggered when the <see cref="IAssignable"/>'s fields are unassigned and completely ready to recycle.
/// </summary>
event OnUnassignedDelegate? OnUnassigned;
Action<IAssignable>? OnUnassigned { get; set; }
/// <summary>
/// Unassign <see cref="IAssignable"/>'s all fields and make it ready to recycle.
@ -17,6 +19,4 @@ public interface IAssignable
/// <see cref="true"/>, if the fields are unsigned successfully, <see cref="false"/> if not.
/// </returns>
bool Unassign();
delegate void OnUnassignedDelegate(IAssignable sender);
}

6
Engine.Core/Abstract/Assignable/IAssignableBehaviourController.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,7 +10,7 @@ public interface IAssignableBehaviourController : IAssignable
/// <summary>
/// Event triggered when the <see cref="IBehaviourController"/> value has has been assigned a new value.
/// </summary>
event OnBehaviourControllerAssignedDelegate? OnBehaviourControllerAssigned;
Action<IAssignableBehaviourController>? OnBehaviourControllerAssigned { get; set; }
/// <inheritdoc cref="IBehaviourController" />
IBehaviourController BehaviourController { get; }
@ -21,6 +23,4 @@ public interface IAssignableBehaviourController : IAssignable
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(IBehaviourController behaviourController);
delegate void OnBehaviourControllerAssignedDelegate(IAssignableBehaviourController sender);
}

6
Engine.Core/Abstract/Assignable/IAssignableEntity.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,7 +10,7 @@ public interface IAssignableEntity : IAssignable
/// <summary>
/// Event triggered when the <see cref="IEntity"/> value has has been assigned a new value.
/// </summary>
event OnEntityAssignedDelegate? OnEntityAssigned;
Action<IAssignableEntity>? OnEntityAssigned { get; set; }
/// <inheritdoc cref="IEntity" />
IEntity Entity { get; }
@ -21,6 +23,4 @@ public interface IAssignableEntity : IAssignable
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(IEntity entity);
delegate void OnEntityAssignedDelegate(IAssignableEntity sender);
}

6
Engine.Core/Abstract/Assignable/IAssignableGameManager.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,7 +10,7 @@ public interface IAssignableGameManager : IAssignable
/// <summary>
/// Event triggered when the <see cref="IGameManager"/> value has has been assigned a new value.
/// </summary>
event OnGameManagerAssignedDelegate? OnGameManagerAssigned;
Action<IAssignableGameManager>? OnGameManagerAssigned { get; set; }
/// <inheritdoc cref="IGameManager" />
IGameManager GameManager { get; }
@ -21,6 +23,4 @@ public interface IAssignableGameManager : IAssignable
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(IGameManager gameManager);
delegate void OnGameManagerAssignedDelegate(IAssignableGameManager sender);
}

6
Engine.Core/Abstract/Assignable/IAssignableGameObject.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,7 +10,7 @@ public interface IAssignableGameObject : IAssignable
/// <summary>
/// Event triggered when the <see cref="IGameObject"/> value has has been assigned a new value.
/// </summary>
event OnGameObjectAssignedDelegate? OnGameObjectAssigned;
Action<IAssignableGameObject>? OnGameObjectAssigned { get; set; }
/// <inheritdoc cref="IGameObject" />
IGameObject GameObject { get; }
@ -21,6 +23,4 @@ public interface IAssignableGameObject : IAssignable
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(IGameObject gameObject);
delegate void OnGameObjectAssignedDelegate(IAssignableGameObject sender);
}

6
Engine.Core/Abstract/Assignable/IAssignableStateEnable.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,7 +10,7 @@ public interface IAssignableStateEnable : IAssignable
/// <summary>
/// Event triggered when the <see cref="IStateEnable"/> value has has been assigned a new value.
/// </summary>
event OnStateEnableAssignedDelegate? OnStateEnableAssigned;
Action<IAssignableStateEnable>? OnStateEnableAssigned { get; set; }
/// <inheritdoc cref="IStateEnable" />
IStateEnable StateEnable { get; }
@ -21,6 +23,4 @@ public interface IAssignableStateEnable : IAssignable
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(IStateEnable stateEnable);
delegate void OnStateEnableAssignedDelegate(IAssignableStateEnable sender);
}

6
Engine.Core/Abstract/Assignable/IAssignableTransform.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,7 +10,7 @@ public interface IAssignableTransform : IAssignable
/// <summary>
/// Event triggered when the <see cref="ITransform"/> value has has been assigned a new value.
/// </summary>
event OnTransformAssignedDelegate? OnTransformAssigned;
Action<IAssignableTransform>? OnTransformAssigned { get; set; }
/// <inheritdoc cref="ITransform" />
ITransform Transform { get; }
@ -21,6 +23,4 @@ public interface IAssignableTransform : IAssignable
/// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
/// </returns>
bool Assign(ITransform transform);
delegate void OnTransformAssignedDelegate(IAssignableTransform sender);
}

64
Engine.Core/Abstract/Assignable/IHierarchyObject.cs
View File

@ -1,64 +0,0 @@
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents an <see cref="IEntity"/> that can enter and exit a hierarchy within the <see cref="IGameManager"/> system.
/// This interface allows for tracking the object's presence in the hierarchy and provides events
/// for notifying when the see enters or exits the hierarchy.
/// </summary>
public interface IHierarchyObject : IEntity, INameable
{
/// <summary>
/// Event triggered when the <see cref="IEntity"/> enters the hierarchy.
/// </summary>
event OnEnteredHierarchyDelegate? OnEnteredHierarchy;
/// <summary>
/// Event triggered when the <see cref="IEntity"/> exits the hierarchy.
/// </summary>
event OnExitedHierarchyDelegate? OnExitedHierarchy;
/// <summary>
/// Gets the <see cref="IGameManager"/> associated with this <see cref="IEntity"/> , if any.
/// </summary>
IGameManager? GameManager { get; }
/// <summary>
/// Indicates whether the <see cref="IEntity"/> is currently in the hierarchy.
/// </summary>
bool IsInHierarchy { get; }
/// <summary>
/// Internal method to handle entering the hierarchy.
/// This should be called by the system to properly manage hierarchy states.
/// </summary>
/// <param name="gameManager">The game manager that is managing this hierarchy.</param>
/// <returns>
/// <see cref="true"/> if the <see cref="IEntity"/> successfully entered the hierarchy;
/// <see cref="false"/> if it failed to do so.
/// </returns>
internal bool EnterHierarchy(IGameManager gameManager);
/// <summary>
/// Internal method to handle exiting the hierarchy.
/// This should be called by the system to properly manage hierarchy states.
/// </summary>
/// <returns>
/// <see cref="true"/> if the <see cref="IEntity"/> successfully exited the hierarchy;
/// <see cref="false"/> if it failed to do so.
/// </returns>
internal bool ExitHierarchy();
/// <summary>
/// Delegate type for the event triggered when the <see cref="IEntity"/> enters the hierarchy of a <see cref="IGameManager">.
/// </summary>
/// <param name="sender">The <see cref="IEntity"/> that entered the hierarchy.</param>
/// <param name="gameManager">The <see cref="IGameManager"/> that the <see cref="IEntity"/> has entered it's hierarchy.</param>
delegate void OnEnteredHierarchyDelegate(IHierarchyObject sender, IGameManager gameManager);
/// <summary>
/// Delegate type for the event triggered when the <see cref="IEntity"/> exits the hierarchy of a <see cref="IGameManager">.
/// </summary>
/// <param name="sender">The <see cref="IEntity"/> that exited the hierarchy.</param>
/// <param name="gameManager">The <see cref="IGameManager"/> that the <see cref="IEntity"/> has exited it's hierarchy.</param>
delegate void OnExitedHierarchyDelegate(IHierarchyObject sender, IGameManager gameManager);
}

30
Engine.Core/Abstract/BaseEntity.cs
View File

@ -1,18 +1,16 @@
using System;
using Syntriax.Engine.Core.Exceptions;
namespace Syntriax.Engine.Core.Abstract;
public abstract class BaseEntity : IEntity
{
public event IEntity.OnIdChangedDelegate? OnIdChanged = null;
public Action<IEntity, string>? OnIdChanged { get; set; } = null;
public event IInitialize.OnInitializedDelegate? OnInitialized = null;
public event IInitialize.OnFinalizedDelegate? OnFinalized = null;
public Action<IAssignable>? OnUnassigned { get; set; } = null;
public Action<IAssignableStateEnable>? OnStateEnableAssigned { get; set; } = null;
public event IAssignableStateEnable.OnStateEnableAssignedDelegate? OnStateEnableAssigned = null;
public event IAssignable.OnUnassignedDelegate? OnUnassigned = null;
public Action<IInitialize>? OnInitialized { get; set; } = null;
public Action<IInitialize>? OnFinalized { get; set; } = null;
private IStateEnable _stateEnable = null!;
@ -39,7 +37,7 @@ public abstract class BaseEntity : IEntity
}
}
public bool IsInitialized
public bool Initialized
{
get => _initialized;
private set
@ -57,7 +55,7 @@ public abstract class BaseEntity : IEntity
public bool Assign(IStateEnable stateEnable)
{
if (IsInitialized)
if (Initialized)
return false;
_stateEnable = stateEnable;
@ -69,13 +67,11 @@ public abstract class BaseEntity : IEntity
protected virtual void UnassignInternal() { }
public bool Unassign()
{
if (IsInitialized)
if (Initialized)
return false;
UnassignInternal();
_stateEnable = null!;
_stateEnable.Unassign();
OnUnassigned?.Invoke(this);
return true;
}
@ -83,26 +79,24 @@ public abstract class BaseEntity : IEntity
protected virtual void InitializeInternal() { }
public bool Initialize()
{
if (IsInitialized)
if (Initialized)
return false;
NotAssignedException.Check(this, _stateEnable);
InitializeInternal();
IsInitialized = true;
Initialized = true;
return true;
}
protected virtual void FinalizeInternal() { }
public bool Finalize()
{
if (!IsInitialized)
if (!Initialized)
return false;
FinalizeInternal();
IsInitialized = false;
Initialized = false;
return true;
}

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

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,7 +10,7 @@ public interface IBehaviour : IEntity, IAssignableBehaviourController, IAssignab
/// <summary>
/// Event triggered when the priority of the <see cref="IBehaviour"/> changes.
/// </summary>
event OnPriorityChangedDelegate? OnPriorityChanged;
Action<IBehaviour>? OnPriorityChanged { get; set; }
/// <summary>
/// The priority of the <see cref="IBehaviour"/>.
@ -19,6 +21,4 @@ public interface IBehaviour : IEntity, IAssignableBehaviourController, IAssignab
/// The value indicating whether the <see cref="IBehaviour"/> is active.
/// </summary>
bool IsActive { get; }
delegate void OnPriorityChangedDelegate(IBehaviour sender, int previousPriority);
}

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

@ -1,3 +1,4 @@
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
@ -11,27 +12,27 @@ public interface IBehaviourController : IAssignableGameObject, IEnumerable<IBeha
/// <summary>
/// Event triggered before the update of <see cref="IBehaviour"/>s.
/// </summary>
event OnPreUpdateDelegate? OnPreUpdate;
Action<IBehaviourController>? OnPreUpdate { get; set; }
/// <summary>
/// Event triggered during the update of <see cref="IBehaviour"/>s.
/// </summary>
event OnUpdateDelegate? OnUpdate;
Action<IBehaviourController>? OnUpdate { get; set; }
/// <summary>
/// Event triggered before the drawing phase.
/// </summary>
event OnPreDrawDelegate? OnPreDraw;
Action<IBehaviourController>? OnPreDraw { get; set; }
/// <summary>
/// Event triggered when a <see cref="IBehaviour"/> is added to the <see cref="IBehaviourController"/>.
/// </summary>
event OnBehaviourAddedDelegate? OnBehaviourAdded;
Action<IBehaviourController, IBehaviour>? OnBehaviourAdded { get; set; }
/// <summary>
/// Event triggered when a <see cref="IBehaviour"/> is removed from the <see cref="IBehaviourController"/>.
/// </summary>
event OnBehaviourRemovedDelegate? OnBehaviourRemoved;
Action<IBehaviourController, IBehaviour>? OnBehaviourRemoved { get; set; }
/// <summary>
/// Adds a <see cref="IBehaviour"/> to the <see cref="IBehaviourController"/>.
@ -101,11 +102,4 @@ public interface IBehaviourController : IAssignableGameObject, IEnumerable<IBeha
/// Performs pre-draw operations.
/// </summary>
void UpdatePreDraw();
delegate void OnPreUpdateDelegate(IBehaviourController sender);
delegate void OnUpdateDelegate(IBehaviourController sender);
delegate void OnPreDrawDelegate(IBehaviourController sender);
delegate void OnBehaviourAddedDelegate(IBehaviourController sender, IBehaviour behaviourAdded);
delegate void OnBehaviourRemovedDelegate(IBehaviourController sender, IBehaviour behaviourRemoved);
}

8
Engine.Core/Abstract/ICoroutineYield.cs
View File

@ -1,8 +0,0 @@
using System.Collections;
namespace Syntriax.Engine.Core.Abstract;
public interface ICoroutineYield
{
bool Yield();
}

6
Engine.Core/Abstract/IEntity.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -9,12 +11,10 @@ public interface IEntity : IInitialize, IAssignableStateEnable
/// Event triggered when the <see cref="Id"/> of the <see cref="IEntity"/> changes.
/// The string action parameter is the previous <see cref="Id"/> of the <see cref="IEntity"/>.
/// </summary>
event OnIdChangedDelegate? OnIdChanged;
Action<IEntity, string>? OnIdChanged { get; set; }
/// <summary>
/// The ID of the <see cref="IEntity"/>.
/// </summary>
string Id { get; set; }
delegate void OnIdChangedDelegate(IEntity sender, string previousId);
}

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

@ -1,3 +1,4 @@
using System;
using System.Collections.Generic;
namespace Syntriax.Engine.Core.Abstract;
@ -7,35 +8,15 @@ namespace Syntriax.Engine.Core.Abstract;
/// </summary>
public interface IGameManager : IEntity, IEnumerable<IGameObject>
{
/// <summary>
/// Event triggered when <see cref="Update(EngineTime)"/> is called on the <see cref="IGameManager"/>.
/// </summary>
event OnUpdateDelegate? OnUpdate;
/// <summary>
/// Event triggered when <see cref="PreDraw"/> is called on the <see cref="IGameManager"/>.
/// </summary>
event OnPreDawDelegate? OnPreDraw;
/// <summary>
/// Event triggered when a <see cref="IGameObject"/> is registered to the <see cref="IGameManager"/>.
/// </summary>
event OnGameObjectRegisteredDelegate? OnGameObjectRegistered;
Action<IGameManager, IGameObject>? OnGameObjectRegistered { get; set; }
/// <summary>
/// Event triggered when a <see cref="IGameObject"/> is unregistered from the <see cref="IGameManager"/>.
/// </summary>
event OnGameObjectUnRegisteredDelegate? OnGameObjectUnRegistered;
/// <summary>
/// Event triggered when a <see cref="IHierarchyObject"/> is registered to the <see cref="IGameManager"/>.
/// </summary>
event OnHierarchyObjectRegisteredDelegate? OnHierarchyObjectRegistered;
/// <summary>
/// Event triggered when a <see cref="IHierarchyObject"/> is unregistered from the <see cref="IGameManager"/>.
/// </summary>
event OnHierarchyObjectUnRegisteredDelegate? OnHierarchyObjectUnRegistered;
Action<IGameManager, IGameObject>? OnGameObjectUnRegistered { get; set; }
/// <summary>
/// Gets a read-only list of <see cref="IGameObject"/>s managed by the <see cref="IGameManager"/>.
@ -43,15 +24,10 @@ public interface IGameManager : IEntity, IEnumerable<IGameObject>
IReadOnlyList<IGameObject> GameObjects { get; }
/// <summary>
/// Gets a read-only list of <see cref="IHierarchyObject"/>s managed by the <see cref="IGameManager"/>.
/// Registers a <see cref="IGameObject"/> to the <see cref="IGameManager"/>.
/// </summary>
IReadOnlyList<IHierarchyObject> HierarchyObjects { get; }
/// <summary>
/// Registers an <see cref="IHierarchyObject"/> to the <see cref="IGameManager"/>.
/// </summary>
/// <param name="hierarchyObject">The <see cref="IHierarchyObject"/> to register.</param>
void Register(IHierarchyObject hierarchyObject);
/// <param name="gameObject">The <see cref="IGameObject"/> to register.</param>
void RegisterGameObject(IGameObject gameObject);
/// <summary>
/// Instantiates a <see cref="IGameObject"/> of type T with the given arguments and registers it to the <see cref="IGameManager"/>.
@ -62,10 +38,11 @@ public interface IGameManager : IEntity, IEnumerable<IGameObject>
T InstantiateGameObject<T>(params object?[]? args) where T : class, IGameObject;
/// <summary>
/// Removes an <see cref="IHierarchyObject"/> from the <see cref="IGameManager"/>.
/// Removes a <see cref="IGameObject"/> from the <see cref="IGameManager"/>.
/// </summary>
/// <param name="hierarchyObject">The <see cref="IHierarchyObject"/> to remove.</param>
void Remove(IHierarchyObject hierarchyObject);
/// <param name="gameObject">The <see cref="IGameObject"/> to remove.</param>
/// <returns>The removed <see cref="IGameObject"/>.</returns>
IGameObject RemoveGameObject(IGameObject gameObject);
/// <summary>
/// Updates the <see cref="IGameManager"/> with the given engine time data.
@ -77,12 +54,4 @@ public interface IGameManager : IEntity, IEnumerable<IGameObject>
/// Performs operations that should be done before the draw calls.
/// </summary>
void PreDraw();
delegate void OnUpdateDelegate(IGameManager sender, EngineTime time);
delegate void OnPreDawDelegate(IGameManager sender);
delegate void OnGameObjectRegisteredDelegate(IGameManager sender, IGameObject gameObjectRegistered);
delegate void OnGameObjectUnRegisteredDelegate(IGameManager sender, IGameObject gameObjectUnregistered);
delegate void OnHierarchyObjectRegisteredDelegate(IGameManager sender, IHierarchyObject hierarchyObjectRegistered);
delegate void OnHierarchyObjectUnRegisteredDelegate(IGameManager sender, IHierarchyObject hierarchyObjectUnregistered);
}

8
Engine.Core/Abstract/IGameObject.cs
View File

@ -1,19 +1,19 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents a game object with various properties and functionalities.
/// </summary>
public interface IGameObject : IEntity, IHierarchyObject, IAssignableTransform, IAssignableBehaviourController, INameable, IInitialize
public interface IGameObject : IEntity, IAssignableGameManager, IAssignableTransform, IAssignableBehaviourController, INameable, IInitialize
{
/// <summary>
/// Event triggered when the <see cref="Update"/> method is called.
/// </summary>
event OnUpdatedDelegate? OnUpdated;
Action<IGameObject>? OnUpdated { get; set; }
/// <summary>
/// Updates the game object.
/// </summary>
void Update();
delegate void OnUpdatedDelegate(IGameObject sender);
}

11
Engine.Core/Abstract/IInitialize.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,17 +10,17 @@ public interface IInitialize
/// <summary>
/// Event triggered when the <see cref="Initialize"/> method is called successfully.
/// </summary>
event OnInitializedDelegate? OnInitialized;
Action<IInitialize>? OnInitialized { get; set; }
/// <summary>
/// Event triggered when the <see cref="Finalize"/> method is called successfully.
/// </summary>
event OnFinalizedDelegate? OnFinalized;
Action<IInitialize>? OnFinalized { get; set; }
/// <summary>
/// The value indicating whether the entity has been initialized.
/// </summary>
bool IsInitialized { get; }
bool Initialized { get; }
/// <summary>
/// Initializes the entity.
@ -31,7 +33,4 @@ public interface IInitialize
/// </summary>
/// <returns><see cref="true"/> if finalization is successful, otherwise <see cref="false"/>.</returns>
bool Finalize();
delegate void OnInitializedDelegate(IInitialize sender);
delegate void OnFinalizedDelegate(IInitialize sender);
}

6
Engine.Core/Abstract/INameable.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,12 +10,10 @@ public interface INameable
/// <summary>
/// Event triggered when the name of the entity changes.
/// </summary>
event OnNameChangedDelegate? OnNameChanged;
Action<IEntity>? OnNameChanged { get; set; }
/// <summary>
/// The name of the entity.
/// </summary>
string Name { get; set; }
delegate void OnNameChangedDelegate(INameable sender, string previousName);
}

6
Engine.Core/Abstract/IStateEnable.cs
View File

@ -1,3 +1,5 @@
using System;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
@ -8,12 +10,10 @@ public interface IStateEnable : IAssignableEntity
/// <summary>
/// Event triggered when the <see cref="Enabled"/> state of the <see cref="IStateEnable"/> changes.
/// </summary>
event OnNameChangedDelegate? OnEnabledChanged;
Action<IStateEnable>? OnEnabledChanged { get; set; }
/// <summary>
/// The value indicating whether the <see cref="IStateEnable"/> is enabled.
/// </summary>
bool Enabled { get; set; }
delegate void OnNameChangedDelegate(IStateEnable sender, bool previousState);
}

80
Engine.Core/Abstract/ITransform.cs
View File

@ -1,105 +1,39 @@
using System;
using System.Collections.Generic;
namespace Syntriax.Engine.Core.Abstract;
/// <summary>
/// Represents the transformation properties of an object such as position, scale, and rotation.
/// </summary>
public interface ITransform : IAssignableGameObject, IEnumerable<ITransform>
public interface ITransform
{
/// <summary>
/// Event triggered when the <see cref="Position"/> of the <see cref="ITransform"/> changes.
/// </summary>
event OnPositionChangedDelegate? OnPositionChanged;
Action<ITransform>? OnPositionChanged { get; set; }
/// <summary>
/// Event triggered when the <see cref="Scale"/> of the <see cref="ITransform"/> changes.
/// </summary>
event OnScaleChangedDelegate? OnScaleChanged;
Action<ITransform>? OnScaleChanged { get; set; }
/// <summary>
/// Event triggered when the <see cref="Rotation"/> of the <see cref="ITransform"/> changes.
/// </summary>
event OnRotationChangedDelegate? OnRotationChanged;
Action<ITransform>? OnRotationChanged { get; set; }
/// <summary>
/// Event triggered when the <see cref="Parent"/> of the <see cref="ITransform"/> changes. The second parameter is the old <see cref="ITransform"/>.
/// </summary>
event OnParentChangedDelegate? OnParentChanged;
/// <summary>
/// Event triggered when a new <see cref="ITransform"/> is added to the <see cref="Children"/>.
/// </summary>
event OnChildrenAddedDelegate? OnChildrenAdded;
/// <summary>
/// Event triggered when an <see cref="ITransform"/> is removed from the <see cref="Children"/>.
/// </summary>
event OnChildrenRemovedDelegate? OnChildrenRemoved;
/// <summary>
/// The world position of the <see cref="ITransform"/> in 2D space.
/// The position of the <see cref="ITransform"/> in 2D space.
/// </summary>
Vector2D Position { get; set; }
/// <summary>
/// The world scale of the <see cref="ITransform"/>.
/// The scale of the <see cref="ITransform"/>.
/// </summary>
Vector2D Scale { get; set; }
/// <summary>
/// The world rotation of the <see cref="ITransform"/> in degrees.
/// The rotation of the <see cref="ITransform"/> in degrees.
/// </summary>
float Rotation { get; set; }
/// <summary>
/// The local position of the <see cref="ITransform"/> in 2D space.
/// </summary>
Vector2D LocalPosition { get; set; }
/// <summary>
/// The local scale of the <see cref="ITransform"/>.
/// </summary>
Vector2D LocalScale { get; set; }
/// <summary>
/// The local rotation of the <see cref="ITransform"/> in degrees.
/// </summary>
float LocalRotation { get; set; }
/// <summary>
/// The parent <see cref="ITransform"/> of the <see cref="ITransform"/>.
/// </summary>
ITransform? Parent { get; }
/// <summary>
/// The <see cref="ITransform"/>s that have this <see cref="ITransform"/> as their <see cref="Parent"/>.
/// </summary>
IReadOnlyList<ITransform> Children { get; }
/// <summary>
/// Sets the parent <see cref="ITransform"/> of this <see cref="ITransform"/>.
/// </summary>
/// <param name="transform">The parent <see cref="ITransform"/> to set.</param>
void SetParent(ITransform? transform);
/// <summary>
/// Adds a child <see cref="ITransform"/> to this <see cref="ITransform"/>.
/// </summary>
/// <param name="transform">The child <see cref="ITransform"/> to add.</param>
void AddChild(ITransform transform);
/// <summary>
/// Removes a child <see cref="ITransform"/> from this <see cref="ITransform"/>.
/// </summary>
/// <param name="transform">The child <see cref="ITransform"/> to remove.</param>
void RemoveChild(ITransform transform);
delegate void OnPositionChangedDelegate(ITransform sender);
delegate void OnScaleChangedDelegate(ITransform sender);
delegate void OnRotationChangedDelegate(ITransform sender);
delegate void OnParentChangedDelegate(ITransform sender, ITransform? newParent);
delegate void OnChildrenAddedDelegate(ITransform sender, ITransform childrenAdded);
delegate void OnChildrenRemovedDelegate(ITransform sender, ITransform childrenRemoved);
}

120
Engine.Core/Behaviour.cs
View File

@ -1,105 +1,59 @@
using System;
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Core.Exceptions;
namespace Syntriax.Engine.Core;
public abstract class Behaviour : BehaviourBase
[System.Diagnostics.DebuggerDisplay("{GetType().Name, nq}, Priority: {Priority}, Initialized: {Initialized}")]
public abstract class Behaviour : BaseEntity, IBehaviour
{
private bool isInitializedThisFrame = false;
public Action<IAssignableBehaviourController>? OnBehaviourControllerAssigned { get; set; } = null;
protected IGameObject GameObject => BehaviourController.GameObject;
protected ITransform Transform => BehaviourController.GameObject.Transform;
public Action<IBehaviour>? OnPriorityChanged { get; set; } = null;
public Behaviour()
private IBehaviourController _behaviourController = null!;
private int _priority = 0;
public IBehaviourController BehaviourController => _behaviourController;
public override bool IsActive => base.IsActive && BehaviourController.GameObject.StateEnable.Enabled;
public int Priority
{
OnInitialized += OnInitialize;
OnFinalized += OnFinalize;
OnUnassigned += OnUnassign;
}
protected virtual void OnUnassign() { }
private void OnUnassign(IAssignable assignable) => OnUnassign();
protected virtual void OnInitialize() { }
private void OnInitialize(IInitialize _)
get => _priority;
set
{
isInitializedThisFrame = true;
BehaviourController.OnPreUpdate += PreUpdate;
BehaviourController.OnPreDraw += PreDraw;
BehaviourController.OnUpdate += Update;
BehaviourController.GameObject.OnEnteredHierarchy += EnteredHierarchy;
BehaviourController.GameObject.OnExitedHierarchy += ExitedHierarchy;
OnInitialize();
if (GameObject.IsInHierarchy)
EnteredHierarchy(GameObject, GameObject.GameManager ?? throw new System.Exception("Unexpected Error"));
}
protected virtual void OnFinalize() { }
private void OnFinalize(IInitialize _)
{
BehaviourController.OnPreUpdate -= PreUpdate;
BehaviourController.OnPreDraw -= PreDraw;
BehaviourController.OnUpdate -= Update;
BehaviourController.GameObject.OnEnteredHierarchy -= EnteredHierarchy;
BehaviourController.GameObject.OnExitedHierarchy -= ExitedHierarchy;
OnFinalize();
if (GameObject.IsInHierarchy)
ExitedHierarchy(GameObject, GameObject.GameManager ?? throw new System.Exception("Unexpected Error"));
}
protected virtual void OnPreUpdatePreActiveCheck() { }
protected virtual void OnPreUpdate() { }
private void PreUpdate(IBehaviourController _)
{
OnPreUpdatePreActiveCheck();
if (!IsActive)
if (value == _priority)
return;
if (isInitializedThisFrame)
FirstActiveFrame();
OnPreUpdate();
_priority = value;
OnPriorityChanged?.Invoke(this);
}
}
protected virtual void OnFirstActiveFrame() { }
private void FirstActiveFrame()
public bool Assign(IBehaviourController behaviourController)
{
OnFirstActiveFrame();
isInitializedThisFrame = false;
if (Initialized)
return false;
_behaviourController = behaviourController;
OnBehaviourControllerAssigned?.Invoke(this);
return true;
}
protected virtual void OnUpdatePreActiveCheck() { }
protected virtual void OnUpdate() { }
private void Update(IBehaviourController _)
protected override void UnassignInternal()
{
OnUpdatePreActiveCheck();
if (!IsActive)
return;
OnUpdate();
base.UnassignInternal();
_behaviourController = null!;
}
protected virtual void OnPreDrawPreActiveCheck() { }
protected virtual void OnPreDraw() { }
private void PreDraw(IBehaviourController _)
protected override void InitializeInternal()
{
OnPreDrawPreActiveCheck();
if (!StateEnable.Enabled)
return;
OnPreDraw();
base.InitializeInternal();
NotAssignedException.Check(this, _behaviourController);
NotAssignedException.Check(this, StateEnable);
}
protected virtual void OnEnteredHierarchy(IGameManager gameManager) { }
private void EnteredHierarchy(IHierarchyObject sender, IGameManager gameManager) => OnEnteredHierarchy(gameManager);
protected virtual void OnExitedHierarchy(IGameManager gameManager) { }
private void ExitedHierarchy(IHierarchyObject sender, IGameManager gameManager) => OnExitedHierarchy(gameManager);
}

59
Engine.Core/BehaviourBase.cs
View File

@ -1,59 +0,0 @@
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Core.Exceptions;
namespace Syntriax.Engine.Core;
[System.Diagnostics.DebuggerDisplay("{GetType().Name, nq}, Priority: {Priority}, Initialized: {Initialized}")]
public abstract class BehaviourBase : BaseEntity, IBehaviour
{
public event IAssignableBehaviourController.OnBehaviourControllerAssignedDelegate? OnBehaviourControllerAssigned = null;
public event IBehaviour.OnPriorityChangedDelegate? OnPriorityChanged = null;
private IBehaviourController _behaviourController = null!;
private int _priority = 0;
public IBehaviourController BehaviourController => _behaviourController;
public override bool IsActive => base.IsActive && BehaviourController.GameObject.StateEnable.Enabled;
public int Priority
{
get => _priority;
set
{
if (value == _priority)
return;
int previousPriority = _priority;
_priority = value;
OnPriorityChanged?.Invoke(this, previousPriority);
}
}
public bool Assign(IBehaviourController behaviourController)
{
if (IsInitialized)
return false;
_behaviourController = behaviourController;
OnBehaviourControllerAssigned?.Invoke(this);
return true;
}
protected override void UnassignInternal()
{
base.UnassignInternal();
_behaviourController = null!;
}
protected override void InitializeInternal()
{
base.InitializeInternal();
NotAssignedException.Check(this, _behaviourController);
NotAssignedException.Check(this, StateEnable);
}
}

36
Engine.Core/BehaviourCollector.cs → Engine.Core/BehaviourCacher.cs
View File

@ -6,13 +6,13 @@ using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public class BehaviourCollector<T> : IAssignableGameManager, IEnumerable<T>
public class BehaviourCacher<T> : IAssignableGameManager, IEnumerable<T>
{
public event IAssignable.OnUnassignedDelegate? OnUnassigned = null;
public event IAssignableGameManager.OnGameManagerAssignedDelegate? OnGameManagerAssigned = null;
public Action<IAssignable>? OnUnassigned { get; set; } = null;
public Action<IAssignableGameManager>? OnGameManagerAssigned { get; set; } = null;
public event OnCollectedDelegate? OnCollected = null;
public event OnRemovedDelegate? OnRemoved = null;
public Action<BehaviourCacher<T>, T>? OnCached { get; set; } = null;
public Action<BehaviourCacher<T>, T>? OnUncached { get; set; } = null;
private readonly List<T> _behaviours = new(32);
@ -21,25 +21,19 @@ public class BehaviourCollector<T> : IAssignableGameManager, IEnumerable<T>
public T this[Index index] => _behaviours[index];
public BehaviourCollector() { }
public BehaviourCollector(IGameManager gameManager) => Assign(gameManager);
public BehaviourCacher() { }
public BehaviourCacher(IGameManager gameManager) => Assign(gameManager);
private void OnGameObjectRegistered(IGameManager manager, IGameObject gameObject)
{
gameObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
gameObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
foreach (IBehaviour item in gameObject.BehaviourController)
OnBehaviourAdded(gameObject.BehaviourController, item);
}
private void OnGameObjectUnregistered(IGameManager manager, IGameObject gameObject)
{
gameObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
gameObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
foreach (IBehaviour item in gameObject.BehaviourController)
OnBehaviourRemoved(gameObject.BehaviourController, item);
}
private void OnBehaviourAdded(IBehaviourController controller, IBehaviour behaviour)
@ -48,7 +42,7 @@ public class BehaviourCollector<T> : IAssignableGameManager, IEnumerable<T>
return;
_behaviours.Add(tBehaviour);
OnCollected?.Invoke(this, tBehaviour);
OnCached?.Invoke(this, tBehaviour);
}
private void OnBehaviourRemoved(IBehaviourController controller, IBehaviour behaviour)
@ -59,7 +53,7 @@ public class BehaviourCollector<T> : IAssignableGameManager, IEnumerable<T>
if (!_behaviours.Remove(tBehaviour))
return;
OnRemoved?.Invoke(this, tBehaviour);
OnUncached?.Invoke(this, tBehaviour);
}
public bool Assign(IGameManager gameManager)
@ -68,7 +62,11 @@ public class BehaviourCollector<T> : IAssignableGameManager, IEnumerable<T>
return false;
foreach (IGameObject gameObject in gameManager)
{
OnGameObjectRegistered(gameManager, gameObject);
foreach (IBehaviour behaviour in gameObject.BehaviourController)
OnBehaviourAdded(gameObject.BehaviourController, behaviour);
}
gameManager.OnGameObjectRegistered += OnGameObjectRegistered;
gameManager.OnGameObjectUnRegistered += OnGameObjectUnregistered;
@ -85,7 +83,11 @@ public class BehaviourCollector<T> : IAssignableGameManager, IEnumerable<T>
return false;
foreach (IGameObject gameObject in GameManager)
{
OnGameObjectUnregistered(GameManager, gameObject);
foreach (IBehaviour behaviour in gameObject.BehaviourController)
OnBehaviourRemoved(gameObject.BehaviourController, behaviour);
}
GameManager.OnGameObjectRegistered -= OnGameObjectRegistered;
GameManager.OnGameObjectUnRegistered -= OnGameObjectUnregistered;
@ -97,8 +99,4 @@ public class BehaviourCollector<T> : IAssignableGameManager, IEnumerable<T>
public IEnumerator<T> GetEnumerator() => _behaviours.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => _behaviours.GetEnumerator();
public delegate void OnCollectedDelegate(BehaviourCollector<T> sender, T behaviourCollected);
public delegate void OnRemovedDelegate(BehaviourCollector<T> sender, T behaviourRemoved);
}

28
Engine.Core/BehaviourController.cs
View File

@ -11,14 +11,14 @@ namespace Syntriax.Engine.Core;
[System.Diagnostics.DebuggerDisplay("Behaviour Count: {behaviours.Count}")]
public class BehaviourController : IBehaviourController
{
public event IBehaviourController.OnPreUpdateDelegate? OnPreUpdate = null;
public event IBehaviourController.OnUpdateDelegate? OnUpdate = null;
public event IBehaviourController.OnPreDrawDelegate? OnPreDraw = null;
public Action<IBehaviourController>? OnPreUpdate { get; set; }
public Action<IBehaviourController>? OnUpdate { get; set; } = null;
public Action<IBehaviourController>? OnPreDraw { get; set; } = null;
public event IBehaviourController.OnBehaviourAddedDelegate? OnBehaviourAdded = null;
public event IBehaviourController.OnBehaviourRemovedDelegate? OnBehaviourRemoved = null;
public event IAssignable.OnUnassignedDelegate? OnUnassigned;
public event IAssignableGameObject.OnGameObjectAssignedDelegate? OnGameObjectAssigned = null;
public Action<IBehaviourController, IBehaviour>? OnBehaviourAdded { get; set; } = null;
public Action<IBehaviourController, IBehaviour>? OnBehaviourRemoved { get; set; } = null;
public Action<IAssignable>? OnUnassigned { get; set; } = null;
public Action<IAssignableGameObject>? OnGameObjectAssigned { get; set; } = null;
private readonly IList<IBehaviour> behaviours = new List<IBehaviour>(Constants.BEHAVIOURS_SIZE_INITIAL);
@ -32,9 +32,6 @@ public class BehaviourController : IBehaviourController
{
InsertBehaviourByPriority(behaviour);
behaviour.Assign(this);
behaviour.Assign(GameObject.StateEnable);
behaviour.Initialize();
behaviour.OnPriorityChanged += OnPriorityChange;
OnBehaviourAdded?.Invoke(this, behaviour);
@ -113,7 +110,7 @@ public class BehaviourController : IBehaviourController
public bool Assign(IGameObject gameObject)
{
if (GameObject is not null && GameObject.IsInitialized)
if (GameObject is not null && GameObject.Initialized)
return false;
_gameObject = gameObject;
@ -123,7 +120,7 @@ public class BehaviourController : IBehaviourController
public bool Unassign()
{
if (GameObject is not null && GameObject.IsInitialized)
if (GameObject is not null && GameObject.Initialized)
return false;
_gameObject = null!;
@ -168,11 +165,10 @@ public class BehaviourController : IBehaviourController
behaviours.Add(behaviour);
}
private void OnPriorityChange(IBehaviour sender, int previousPriority)
private void OnPriorityChange(IBehaviour behaviour)
{
behaviours.Remove(sender);
InsertBehaviourByPriority(sender);
behaviours.Remove(behaviour);
InsertBehaviourByPriority(behaviour);
}
public IEnumerator<IBehaviour> GetEnumerator() => behaviours.GetEnumerator();

87
Engine.Core/BehaviourOverride.cs Normal file
View File

@ -0,0 +1,87 @@
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public abstract class BehaviourOverride : Behaviour
{
private bool isInitializedThisFrame = false;
protected IGameObject GameObject => BehaviourController.GameObject;
protected ITransform Transform => BehaviourController.GameObject.Transform;
public BehaviourOverride()
{
OnInitialized += OnInitialize;
OnFinalized += OnFinalize;
OnUnassigned += OnUnassign;
}
protected virtual void OnUnassign() { }
private void OnUnassign(IAssignable assignable) => OnUnassign();
protected virtual void OnInitialize() { }
private void OnInitialize(IInitialize _)
{
isInitializedThisFrame = true;
BehaviourController.OnPreUpdate += PreUpdate;
BehaviourController.OnPreDraw += PreDraw;
BehaviourController.OnUpdate += Update;
OnInitialize();
}
protected virtual void OnFinalize() { }
private void OnFinalize(IInitialize _)
{
BehaviourController.OnPreUpdate -= PreUpdate;
BehaviourController.OnPreDraw -= PreDraw;
BehaviourController.OnUpdate -= Update;
OnFinalize();
}
protected virtual void OnPreUpdatePreActiveCheck() { }
protected virtual void OnPreUpdate() { }
private void PreUpdate(IBehaviourController _)
{
OnPreUpdatePreActiveCheck();
if (!IsActive)
return;
if (isInitializedThisFrame)
FirstActiveFrame();
OnPreUpdate();
}
protected virtual void OnFirstActiveFrame() { }
private void FirstActiveFrame()
{
OnFirstActiveFrame();
isInitializedThisFrame = false;
}
protected virtual void OnUpdatePreActiveCheck() { }
protected virtual void OnUpdate() { }
private void Update(IBehaviourController _)
{
OnUpdatePreActiveCheck();
if (!IsActive)
return;
OnUpdate();
}
protected virtual void OnPreDrawPreActiveCheck() { }
protected virtual void OnPreDraw() { }
private void PreDraw(IBehaviourController _)
{
OnPreDrawPreActiveCheck();
if (!StateEnable.Enabled)
return;
OnPreDraw();
}
}

44
Engine.Core/CoroutineManager.cs
View File

@ -1,44 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public class CoroutineManager : HierarchyObjectBase
{
private readonly List<IEnumerator> enumerators = [];
public IEnumerator CreateCoroutine(IEnumerator enumerator)
{
enumerators.Add(enumerator);
return enumerator;
}
public void StopCoroutine(IEnumerator enumerator)
{
enumerators.Remove(enumerator);
}
protected override void OnEnteringHierarchy(IGameManager gameManager)
{
gameManager.OnUpdate += OnUpdate;
}
protected override void OnExitingHierarchy(IGameManager gameManager)
{
gameManager.OnUpdate -= OnUpdate;
}
private void OnUpdate(IGameManager sender, EngineTime time)
{
for (int i = enumerators.Count - 1; i >= 0; i--)
{
if (enumerators[i].Current is ICoroutineYield coroutineYield && coroutineYield.Yield())
continue;
if (!enumerators[i].MoveNext())
enumerators.RemoveAt(i);
}
}
}

12
Engine.Core/CoroutineYield.cs
View File

@ -1,12 +0,0 @@
using System;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public class CoroutineYield(Func<bool> condition) : ICoroutineYield
{
private readonly Func<bool> condition = condition;
public bool Yield() => condition.Invoke();
}

2
Engine.Core/EngineTime.cs
View File

@ -7,5 +7,5 @@ public readonly struct EngineTime(TimeSpan Total, TimeSpan Elapsed)
public readonly TimeSpan Total = Total;
public readonly TimeSpan Elapsed = Elapsed;
public readonly float DeltaTimeFrame = (float)Elapsed.TotalMilliseconds * .001f;
public readonly float DeltaTimeFrame = (float)Elapsed.TotalMilliseconds;
}

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

@ -1,47 +0,0 @@
using System.Diagnostics.CodeAnalysis;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public static class BehaviourControllerExtensions
{
public static bool TryGetBehaviourInParent<T>(this IBehaviourController behaviourController, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
{
behaviour = GetBehaviourInParent<T>(behaviourController);
return behaviour is not null;
}
public static T? GetBehaviourInParent<T>(this IBehaviourController behaviourController) where T : class
{
IBehaviourController? controller = behaviourController;
while (controller is not null)
{
if (behaviourController.GetBehaviour<T>() is T behaviour)
return behaviour;
controller = controller.GameObject.Transform.Parent?.GameObject.BehaviourController;
}
return default;
}
public static bool TryGetBehaviourInChildren<T>(this IBehaviourController behaviourController, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
{
behaviour = GetBehaviourInChildren<T>(behaviourController);
return behaviour is not null;
}
public static T? GetBehaviourInChildren<T>(this IBehaviourController behaviourController) where T : class
{
if (behaviourController.GetBehaviour<T>() is T localBehaviour)
return localBehaviour;
foreach (ITransform transform in behaviourController.GameObject.Transform)
if (GetBehaviourInChildren<T>(transform.GameObject.BehaviourController) is T behaviour)
return behaviour;
return default;
}
}

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

@ -7,22 +7,18 @@ namespace Syntriax.Engine.Core;
public static class BehaviourExtensions
{
public static T? FindBehaviour<T>(this IEnumerable<IGameObject> gameObjects) where T : class
public static bool TryFindBehaviour<T>(this IEnumerable<IGameObject> gameObjects, [NotNullWhen(returnValue: true)] out T? behaviour)
{
behaviour = default;
foreach (IGameObject gameObject in gameObjects)
if (gameObject.BehaviourController.TryGetBehaviour(out T? behaviour))
return behaviour;
if (gameObject.BehaviourController.TryGetBehaviour(out behaviour))
return true;
return default;
return false;
}
public static bool TryFindBehaviour<T>(this IEnumerable<IGameObject> gameObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
{
behaviour = FindBehaviour<T>(gameObjects);
return behaviour is not null;
}
public static void FindBehaviours<T>(this IEnumerable<IGameObject> gameObjects, List<T> behaviours) where T : class
public static void FindBehaviours<T>(this IEnumerable<IGameObject> gameObjects, List<T> behaviours)
{
behaviours.Clear();
List<T> cache = [];

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

@ -1,32 +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? FindObject<T>(this IEnumerable<IHierarchyObject> hierarchyObjects) where T : class
{
foreach (IHierarchyObject hierarchyObject in hierarchyObjects)
if (hierarchyObject is T @object)
return @object;
return default;
}
public static bool TryFindObject<T>(this IEnumerable<IHierarchyObject> hierarchyObjects, [NotNullWhen(returnValue: true)] out T? behaviour) where T : class
{
behaviour = FindObject<T>(hierarchyObjects);
return behaviour is not null;
}
public static void FindObjects<T>(this IEnumerable<IHierarchyObject> hierarchyObjects, List<T> behaviours) where T : class
{
behaviours.Clear();
foreach (IHierarchyObject hierarchyObject in hierarchyObjects)
if (hierarchyObject is T @object)
behaviours.Add(@object);
}
}

7
Engine.Core/Extensions/TransformExtensions.cs
View File

@ -4,16 +4,11 @@ namespace Syntriax.Engine.Core;
public static class TransformExtensions
{
public static ITransform SetTransform(this ITransform transform,
Vector2D? position = null, float? rotation = null, Vector2D? scale = null,
Vector2D? localPosition = null, float? localRotation = null, Vector2D? localScale = null)
public static ITransform SetTransform(this ITransform transform, Vector2D? position = null, float? rotation = null, Vector2D? scale = null)
{
if (position.HasValue) transform.Position = position.Value;
if (rotation.HasValue) transform.Rotation = rotation.Value;
if (scale.HasValue) transform.Scale = scale.Value;
if (localPosition.HasValue) transform.LocalPosition = localPosition.Value;
if (localRotation.HasValue) transform.LocalRotation = localRotation.Value;
if (localScale.HasValue) transform.LocalScale = localScale.Value;
return transform;
}
}

3
Engine.Core/Factory/GameObjectFactory.cs
View File

@ -22,9 +22,6 @@ public class GameObjectFactory
behaviourController ??= TypeFactory.Get<BehaviourController>();
stateEnable ??= TypeFactory.Get<StateEnable>();
if (!transform.Assign(gameObject))
throw AssignException.From(transform, gameObject);
if (!behaviourController.Assign(gameObject))
throw AssignException.From(behaviourController, gameObject);
if (!stateEnable.Assign(gameObject))

89
Engine.Core/GameManager.cs
View File

@ -11,16 +11,11 @@ namespace Syntriax.Engine.Core;
[System.Diagnostics.DebuggerDisplay("GameObject Count: {_gameObjects.Count}")]
public class GameManager : BaseEntity, IGameManager
{
public event IGameManager.OnUpdateDelegate? OnUpdate = null;
public event IGameManager.OnPreDawDelegate? OnPreDraw = null;
public Action<IGameManager, IGameObject>? OnGameObjectRegistered { get; set; } = null;
public Action<IGameManager, IGameObject>? OnGameObjectUnRegistered { get; set; } = null;
public event IGameManager.OnGameObjectRegisteredDelegate? OnGameObjectRegistered = null;
public event IGameManager.OnGameObjectUnRegisteredDelegate? OnGameObjectUnRegistered = null;
public event IGameManager.OnHierarchyObjectRegisteredDelegate? OnHierarchyObjectRegistered = null;
public event IGameManager.OnHierarchyObjectUnRegisteredDelegate? OnHierarchyObjectUnRegistered = null;
private readonly List<IGameObject> _gameObjects = new(Constants.GAME_OBJECTS_SIZE_INITIAL);
private readonly List<IHierarchyObject> _hierarchyObjects = new(Constants.GAME_OBJECTS_SIZE_INITIAL);
private GameObjectFactory _gameObjectFactory = null!;
@ -35,7 +30,6 @@ public class GameManager : BaseEntity, IGameManager
}
public IReadOnlyList<IGameObject> GameObjects => _gameObjects;
public IReadOnlyList<IHierarchyObject> HierarchyObjects => _hierarchyObjects;
public override IStateEnable StateEnable
{
@ -52,23 +46,12 @@ public class GameManager : BaseEntity, IGameManager
}
}
public void Register(IHierarchyObject hierarchyObject)
public void RegisterGameObject(IGameObject gameObject)
{
if (_hierarchyObjects.Contains(hierarchyObject))
throw new Exception($"{nameof(IHierarchyObject)} named {hierarchyObject.Name} is already registered to the {nameof(GameManager)}.");
if (_gameObjects.Contains(gameObject))
throw new Exception($"{nameof(IGameObject)} named {gameObject.Name} is already registered to the {nameof(GameManager)}.");
if (hierarchyObject is IGameObject gameObject)
Register(gameObject);
else
{
if (!hierarchyObject.Initialize())
throw new Exception($"{nameof(hierarchyObject)} can't be initialized");
_hierarchyObjects.Add(hierarchyObject);
hierarchyObject.EnterHierarchy(this);
OnHierarchyObjectRegistered?.Invoke(this, hierarchyObject);
}
}
public T InstantiateGameObject<T>(params object?[]? args) where T : class, IGameObject
@ -78,23 +61,13 @@ public class GameManager : BaseEntity, IGameManager
return gameObject;
}
public void Remove(IHierarchyObject hierarchyObject)
public IGameObject RemoveGameObject(IGameObject gameObject)
{
if (!_hierarchyObjects.Contains(hierarchyObject))
throw new Exception($"{nameof(IHierarchyObject)} named {hierarchyObject.Name} is not registered to the {nameof(GameManager)}.");
if (!_gameObjects.Contains(gameObject))
throw new Exception($"{nameof(IGameObject)} named {gameObject.Name} is not registered to the {nameof(GameManager)}.");
if (hierarchyObject is IGameObject gameObject)
Unregister(gameObject);
else
{
_hierarchyObjects.Remove(hierarchyObject);
hierarchyObject.ExitHierarchy();
if (!hierarchyObject.Finalize())
throw new Exception($"{nameof(hierarchyObject)} can't be finalized");
OnHierarchyObjectUnRegistered?.Invoke(this, hierarchyObject);
}
return gameObject;
}
protected override void InitializeInternal()
@ -116,61 +89,33 @@ public class GameManager : BaseEntity, IGameManager
public void Update(EngineTime time)
{
Time.SetTime(time);
for (int i = 0; i < GameObjects.Count; i++)
GameObjects[i].BehaviourController.Update();
OnUpdate?.Invoke(this, time);
foreach (var gameObject in GameObjects)
gameObject.BehaviourController.Update();
}
public void PreDraw()
{
for (int i = 0; i < GameObjects.Count; i++)
GameObjects[i].BehaviourController.UpdatePreDraw();
OnPreDraw?.Invoke(this);
foreach (var gameObject in GameObjects)
gameObject.BehaviourController.UpdatePreDraw();
}
/////////////////////////////////////////////////////////////////
private void Register(IGameObject gameObject)
{
if (_gameObjects.Contains(gameObject))
throw new Exception($"{nameof(IGameObject)} named {gameObject.Name} is already registered to the {nameof(GameManager)}.");
gameObject.Assign(this);
gameObject.OnFinalized += OnGameObjectFinalize;
gameObject.OnExitedHierarchy += OnGameObjectExitedHierarchy;
if (!gameObject.Initialize())
throw new Exception($"{nameof(gameObject)} can't be initialized");
_gameObjects.Add(gameObject);
_hierarchyObjects.Add(gameObject);
if (!gameObject.EnterHierarchy(this))
throw new Exception($"{nameof(gameObject)} can't enter the hierarchy");
OnHierarchyObjectRegistered?.Invoke(this, gameObject);
OnGameObjectRegistered?.Invoke(this, gameObject);
}
private void Unregister(IGameObject gameObject)
{
if (!_gameObjects.Contains(gameObject))
throw new Exception($"{nameof(IGameObject)} named {gameObject.Name} is not registered to the {nameof(GameManager)}.");
gameObject.OnFinalized -= OnGameObjectFinalize;
gameObject.OnExitedHierarchy -= OnGameObjectExitedHierarchy;
_gameObjects.Remove(gameObject);
_hierarchyObjects.Remove(gameObject);
if (!gameObject.ExitHierarchy())
throw new Exception($"{nameof(gameObject)} can't exit the hierarchy");
if (!gameObject.Finalize())
throw new Exception($"{nameof(gameObject)} can't be finalized");
OnHierarchyObjectUnRegistered?.Invoke(this, gameObject);
OnGameObjectUnRegistered?.Invoke(this, gameObject);
}
@ -180,12 +125,6 @@ public class GameManager : BaseEntity, IGameManager
Unregister(gameObject);
}
private void OnGameObjectExitedHierarchy(IHierarchyObject sender, IGameManager gameManager)
{
if (sender is IGameObject gameObject)
Unregister(gameObject);
}
/////////////////////////////////////////////////////////////////
public IEnumerator<IGameObject> GetEnumerator() => _gameObjects.GetEnumerator();

66
Engine.Core/GameObject.cs
View File

@ -1,3 +1,5 @@
using System;
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Core.Exceptions;
@ -6,26 +8,25 @@ namespace Syntriax.Engine.Core;
[System.Diagnostics.DebuggerDisplay("Name: {Name}, Initialized: {Initialized}")]
public class GameObject : BaseEntity, IGameObject
{
public event IHierarchyObject.OnEnteredHierarchyDelegate? OnEnteredHierarchy = null;
public event IHierarchyObject.OnExitedHierarchyDelegate? OnExitedHierarchy = null;
public Action<IAssignableTransform>? OnTransformAssigned { get; set; } = null;
public Action<IAssignableBehaviourController>? OnBehaviourControllerAssigned { get; set; } = null;
public Action<IAssignableGameManager>? OnGameManagerAssigned { get; set; } = null;
public event IAssignableTransform.OnTransformAssignedDelegate? OnTransformAssigned = null;
public event IAssignableBehaviourController.OnBehaviourControllerAssignedDelegate? OnBehaviourControllerAssigned = null;
public Action<IEntity>? OnNameChanged { get; set; } = null;
public event INameable.OnNameChangedDelegate? OnNameChanged = null;
public Action<IGameObject>? OnUpdated { get; set; } = null;
public event IGameObject.OnUpdatedDelegate? OnUpdated = null;
private ITransform _transform = null!;
private IBehaviourController _behaviourController = null!;
private IGameManager? _gameManager = null;
private IStateEnable _stateEnable = null!;
private IGameManager _gameManager = null!;
private string _name = nameof(GameObject);
public ITransform Transform => _transform;
public IBehaviourController BehaviourController => _behaviourController;
public IGameManager? GameManager => _gameManager;
public bool IsInHierarchy => GameManager is not null;
public IGameManager GameManager => _gameManager;
public string Name
{
@ -34,9 +35,8 @@ public class GameObject : BaseEntity, IGameObject
{
if (value == _name) return;
string previousName = _name;
_name = value;
OnNameChanged?.Invoke(this, previousName);
OnNameChanged?.Invoke(this);
}
}
@ -46,11 +46,13 @@ public class GameObject : BaseEntity, IGameObject
NotAssignedException.Check(this, _transform);
NotAssignedException.Check(this, _behaviourController);
NotAssignedException.Check(this, _stateEnable);
NotAssignedException.Check(this, _gameManager);
}
public void Update()
{
if (!StateEnable.Enabled)
if (!_stateEnable.Enabled)
return;
OnUpdated?.Invoke(this);
@ -66,7 +68,7 @@ public class GameObject : BaseEntity, IGameObject
public bool Assign(ITransform transform)
{
if (IsInitialized)
if (Initialized)
return false;
_transform = transform;
@ -76,7 +78,7 @@ public class GameObject : BaseEntity, IGameObject
public bool Assign(IBehaviourController behaviourController)
{
if (IsInitialized)
if (Initialized)
return false;
_behaviourController = behaviourController;
@ -84,42 +86,32 @@ public class GameObject : BaseEntity, IGameObject
return true;
}
public bool Assign(IGameManager gameManager)
{
if (Initialized)
return false;
_gameManager = gameManager;
OnGameManagerAssigned?.Invoke(this);
return true;
}
protected override void UnassignInternal()
{
base.UnassignInternal();
_stateEnable = null!;
_transform = null!;
_behaviourController = null!;
_gameManager = null!;
}
public GameObject() { OnBehaviourControllerAssigned += ConnectBehaviourController; }
private void ConnectBehaviourController(IAssignableBehaviourController controller)
{
controller.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
controller.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
}
private void OnBehaviourRemoved(IBehaviourController _, IBehaviour behaviour) { if (IsInitialized) behaviour.Finalize(); }
private void OnBehaviourAdded(IBehaviourController _, IBehaviour behaviour) { if (!IsInitialized) behaviour.Initialize(); }
bool IHierarchyObject.EnterHierarchy(IGameManager gameManager)
{
if (IsInHierarchy)
return false;
_gameManager = gameManager;
OnEnteredHierarchy?.Invoke(this, gameManager);
return true;
}
bool IHierarchyObject.ExitHierarchy()
{
if (!IsInHierarchy || _gameManager is not IGameManager gameManager)
return false;
_gameManager = null;
OnExitedHierarchy?.Invoke(this, gameManager);
return true;
}
private void OnBehaviourRemoved(IBehaviourController _, IBehaviour behaviour) { if (Initialized) behaviour.Initialize(); }
private void OnBehaviourAdded(IBehaviourController _, IBehaviour behaviour) { if (Initialized) behaviour.Finalize(); }
}

142
Engine.Core/HierarchyObjectBase.cs
View File

@ -1,142 +0,0 @@
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public abstract class HierarchyObjectBase : IHierarchyObject
{
public event IHierarchyObject.OnEnteredHierarchyDelegate? OnEnteredHierarchy = null;
public event IHierarchyObject.OnExitedHierarchyDelegate? OnExitedHierarchy = null;
public event IEntity.OnIdChangedDelegate? OnIdChanged = null;
public event IInitialize.OnInitializedDelegate? OnInitialized = null;
public event IInitialize.OnFinalizedDelegate? OnFinalized = null;
public event IAssignableStateEnable.OnStateEnableAssignedDelegate? OnStateEnableAssigned = null;
public event IAssignable.OnUnassignedDelegate? OnUnassigned = null;
public event INameable.OnNameChangedDelegate? OnNameChanged = null;
private string _id = string.Empty;
private string _name = nameof(HierarchyObjectBase);
private bool _initialized = false;
private IStateEnable _stateEnable = null!;
private IGameManager? _gameManager = null;
public IGameManager? GameManager => _gameManager;
public bool IsInHierarchy => _gameManager is not null;
public bool IsInitialized
{
get => _initialized;
private set
{
if (value == _initialized)
return;
_initialized = value;
if (value)
OnInitialized?.Invoke(this);
else
OnFinalized?.Invoke(this);
}
}
public virtual IStateEnable StateEnable => _stateEnable;
public string Name
{
get => _name;
set
{
if (value == _name) return;
string previousName = _name;
_name = value;
OnNameChanged?.Invoke(this, previousName);
}
}
public string Id
{
get => _id;
set
{
if (value == _id)
return;
string previousId = _id;
_id = value;
OnIdChanged?.Invoke(this, previousId);
}
}
public bool Assign(IStateEnable stateEnable)
{
if (IsInitialized)
return false;
_stateEnable = stateEnable;
_stateEnable.Assign(this);
OnStateEnableAssigned?.Invoke(this);
return true;
}
protected virtual void UnassignInternal() { }
public bool Unassign()
{
if (IsInitialized)
return false;
UnassignInternal();
OnUnassigned?.Invoke(this);
return true;
}
protected virtual void InitializeInternal() { }
public bool Initialize()
{
if (IsInitialized)
return false;
InitializeInternal();
IsInitialized = true;
return true;
}
protected virtual void FinalizeInternal() { }
public bool Finalize()
{
if (!IsInitialized)
return false;
FinalizeInternal();
IsInitialized = false;
return true;
}
protected virtual void OnEnteringHierarchy(IGameManager gameManager) { }
bool IHierarchyObject.EnterHierarchy(IGameManager gameManager)
{
if (IsInHierarchy)
return false;
_gameManager = gameManager;
OnEnteringHierarchy(gameManager);
OnEnteredHierarchy?.Invoke(this, gameManager);
return true;
}
protected virtual void OnExitingHierarchy(IGameManager gameManager) { }
bool IHierarchyObject.ExitHierarchy()
{
if (!IsInHierarchy || _gameManager is not IGameManager gameManager)
return false;
_gameManager = null;
OnExitingHierarchy(gameManager);
OnExitedHierarchy?.Invoke(this, gameManager);
return true;
}
}

30
Engine.Core/Math.cs
View File

@ -4,8 +4,7 @@ using System.Numerics;
namespace Syntriax.Engine.Core;
public static class Math
{
/// <summary>
{/// <summary>
/// The value of Pi (π), a mathematical constant approximately equal to 3.14159.
/// </summary>
public const float PI = 3.1415926535897932f;
@ -38,20 +37,6 @@ public static class Math
/// <returns>The absolute value of <paramref name="x"/>.</returns>
public static T Abs<T>(T x) where T : INumber<T> => x > T.Zero ? x : -x;
/// <summary>
/// Returns the cosine of a number.
/// </summary>
/// <param name="x">The number.</param>
/// <returns>The cosine of <paramref name="x"/>.</returns>
public static float Cos(float x) => MathF.Cos(x);
/// <summary>
/// Returns the sine of a number.
/// </summary>
/// <param name="x">The number.</param>
/// <returns>The sine of <paramref name="x"/>.</returns>
public static float Sin(float x) => MathF.Sin(x);
/// <summary>
/// Returns the arccosine of a number.
/// </summary>
@ -89,7 +74,7 @@ public static class Math
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
/// <returns>The clamped value.</returns>
public static T Clamp<T>(T x, T min, T max) where T : INumber<T> => (x < min) ? min : (x > max) ? max : x;
public static T Clamp<T>(this T x, T min, T max) where T : INumber<T> => (x < min) ? min : (x > max) ? max : x;
/// <summary>
/// Returns the smallest integral value that is greater than or equal to the specified number.
@ -171,16 +156,6 @@ public static class Math
/// <returns>The number <paramref name="x"/> raised to the power <paramref name="y"/>.</returns>
public static float Pow(float x, float y) => MathF.Pow(x, y);
/// <summary>
/// Performs linear interpolation between two specified values.
/// </summary>
/// <typeparam name="T">The type of the values, which must implement <see cref="IFloatingPoint{T}"/>.</typeparam>
/// <param name="x">The starting value of the interpolation.</param>
/// <param name="y">The ending value of the interpolation.</param>
/// <param name="t">The interpolation factor, typically in the range [0, 1].</param>
/// <returns>A value that represents the linear interpolation between <paramref name="x"/> and <paramref name="y"/>.</returns>
public static T Lerp<T>(T x, T y, T t) where T : IFloatingPoint<T> => x + (y - x) * t;
/// <summary>
/// Rounds a number to a specified number of fractional digits.
/// </summary>
@ -211,4 +186,5 @@ public static class Math
/// <param name="x">The number.</param>
/// <returns>The integral part of <paramref name="x"/>.</returns>
public static float Truncate(float x) => MathF.Truncate(x);
}

76
Engine.Core/MathExtensions.cs
View File

@ -1,76 +0,0 @@
using System;
using System.Numerics;
namespace Syntriax.Engine.Core;
public static class MathExtensions
{
/// <inheritdoc cref="Math.Abs{T}(T)" />
public static T Abs<T>(this T x) where T : INumber<T> => Math.Abs(x);
/// <inheritdoc cref="Math.Cos(float)" />
public static float Cos(this float x) => Math.Cos(x);
/// <inheritdoc cref="Math.Sin(float)" />
public static float Sin(this float x) => Math.Sin(x);
/// <inheritdoc cref="Math.Acos(float)" />
public static float Acos(this float x) => Math.Acos(x);
/// <inheritdoc cref="Math.Asin(float)" />
public static float Asin(this float x) => Math.Asin(x);
/// <inheritdoc cref="Math.Atan2(float, float)" />
public static float Atan2(this float y, float x) => Math.Atan2(y, x);
/// <inheritdoc cref="Math.Atanh(float)" />
public static float Atanh(this float x) => Math.Atanh(x);
/// <inheritdoc cref="Math.Clamp{T}(T, T, T)" />
public static T Clamp<T>(this T x, T min, T max) where T : INumber<T> => Math.Clamp(x, min, max);
/// <inheritdoc cref="Math.Ceiling(float)" />
public static float Ceiling(this float x) => Math.Ceiling(x);
/// <inheritdoc cref="Math.CopySign(float, float)" />
public static float CopySign(this float x, float y) => Math.CopySign(x, y);
/// <inheritdoc cref="Math.Floor(float)" />
public static float Floor(this float x) => Math.Floor(x);
/// <inheritdoc cref="Math.IEEERemainder(float, float)" />
public static float IEEERemainder(this float x, float y) => Math.IEEERemainder(x, y);
/// <inheritdoc cref="Math.Log(float, float)" />
public static float Log(this float x, float y) => Math.Log(x, y);
/// <inheritdoc cref="Math.Max{T}(T, T)" />
public static T Max<T>(this T x, T y) where T : INumber<T> => Math.Max(x, y);
/// <inheritdoc cref="Math.AbsMax{T}(T, T)" />
public static T AbsMax<T>(this T x, T y) where T : INumber<T> => Math.AbsMax(x, y);
/// <inheritdoc cref="Math.Min{T}(T, T)" />
public static T Min<T>(this T x, T y) where T : INumber<T> => Math.Min(x, y);
/// <inheritdoc cref="Math.AbsMin{T}(T, T)" />
public static T AbsMin<T>(this T x, T y) where T : INumber<T> => Math.AbsMin(x, y);
/// <inheritdoc cref="Math.Pow(float, float)" />
public static float Pow(this float x, float y) => Math.Pow(x, y);
/// <inheritdoc cref="Math.Lerp{T}(T, T, T)" />
public static T Lerp<T>(this T x, T y, T t) where T : IFloatingPoint<T> => Math.Lerp(x, y, t);
/// <inheritdoc cref="Math.Round(float, int, MidpointRounding)" />
public static float Round(this float x, int digits, MidpointRounding mode) => Math.Round(x, digits, mode);
/// <inheritdoc cref="Math.Sqr{T}(T)" />
public static T Sqr<T>(this T x) where T : INumber<T> => Math.Sqr(x);
/// <inheritdoc cref="Math.Sqrt(float)" />
public static float Sqrt(this float x) => Math.Sqrt(x);
/// <inheritdoc cref="Math.Truncate(float)" />
public static float Truncate(this float x) => Math.Truncate(x);
}

13
Engine.Core/StateEnable.cs
View File

@ -1,12 +1,14 @@
using System;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
public class StateEnable : IStateEnable
{
public event IAssignable.OnUnassignedDelegate? OnUnassigned = null;
public event IAssignableEntity.OnEntityAssignedDelegate? OnEntityAssigned = null;
public event IStateEnable.OnNameChangedDelegate? OnEnabledChanged = null;
public Action<IAssignable>? OnUnassigned { get; set; } = null;
public Action<IAssignableEntity>? OnEntityAssigned { get; set; } = null;
public Action<IStateEnable>? OnEnabledChanged { get; set; } = null;
private bool _enabled = true;
private IEntity _entity = null!;
@ -21,15 +23,14 @@ public class StateEnable : IStateEnable
if (value == _enabled)
return;
bool previousState = _enabled;
_enabled = value;
OnEnabledChanged?.Invoke(this, previousState);
OnEnabledChanged?.Invoke(this);
}
}
public bool Assign(IEntity entity)
{
if (_entity is not null && _entity.IsInitialized)
if (_entity is not null && _entity.Initialized)
return false;
_entity = entity;

240
Engine.Core/Transform.cs
View File

@ -1,41 +1,20 @@
using System.Collections;
using System.Collections.Generic;
using System;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Core;
[System.Diagnostics.DebuggerDisplay("Name: {GameObject.Name, nq} Position: {Position.ToString(), nq}, Scale: {Scale.ToString(), nq}, Rotation: {Rotation}")]
[System.Diagnostics.DebuggerDisplay("Position: {Position.ToString(), nq}, Scale: {Scale.ToString(), nq}, Rotation: {Rotation}")]
public class Transform : ITransform
{
public event IAssignableGameObject.OnGameObjectAssignedDelegate? OnGameObjectAssigned = null;
public event IAssignable.OnUnassignedDelegate? OnUnassigned = null;
public event ITransform.OnPositionChangedDelegate? OnPositionChanged = null;
public event ITransform.OnScaleChangedDelegate? OnScaleChanged = null;
public event ITransform.OnRotationChangedDelegate? OnRotationChanged = null;
public event ITransform.OnParentChangedDelegate? OnParentChanged = null;
public event ITransform.OnChildrenAddedDelegate? OnChildrenAdded = null;
public event ITransform.OnChildrenRemovedDelegate? OnChildrenRemoved = null;
public Action<ITransform>? OnPositionChanged { get; set; } = null;
public Action<ITransform>? OnScaleChanged { get; set; } = null;
public Action<ITransform>? OnRotationChanged { get; set; } = null;
private Vector2D _position = Vector2D.Zero;
private Vector2D _scale = Vector2D.One;
private float _rotation = 0f;
private Vector2D _localPosition = Vector2D.Zero;
private Vector2D _localScale = Vector2D.One;
private float _localRotation = 0f;
private readonly List<ITransform> _children = [];
public IGameObject GameObject { get; private set; } = null!;
public ITransform? Parent { get; private set; } = null;
public IReadOnlyList<ITransform> Children => _children;
public Vector2D Position
{
get => _position;
@ -45,238 +24,33 @@ public class Transform : ITransform
return;
_position = value;
UpdateLocalPosition();
OnPositionChanged?.Invoke(this);
}
}
public Vector2D Scale
{
get => _localScale.Scale(Parent?.Scale ?? Vector2D.One);
get => _scale;
set
{
if (value == _scale)
return;
_scale = value;
UpdateLocalScale();
OnScaleChanged?.Invoke(this);
}
}
public float Rotation
{
get => _localRotation + (Parent?.Rotation ?? 0f);
get => _rotation;
set
{
if (value == _rotation)
return;
_rotation = value;
UpdateLocalPosition();
OnRotationChanged?.Invoke(this);
}
}
public Vector2D LocalPosition
{
get => _localPosition;
set
{
if (value == _localPosition)
return;
_localPosition = value;
UpdatePosition();
OnPositionChanged?.Invoke(this);
}
}
public Vector2D LocalScale
{
get => _localScale;
set
{
if (value == _localScale)
return;
_localScale = value;
UpdateScale();
OnScaleChanged?.Invoke(this);
}
}
public float LocalRotation
{
get => _localRotation;
set
{
if (value == _localRotation)
return;
_localRotation = value;
UpdateRotation();
OnRotationChanged?.Invoke(this);
}
}
public void SetParent(ITransform? transform)
{
if (transform == this || Parent == transform)
return;
ITransform? previousParent = Parent;
if (previousParent is not null)
{
previousParent.RemoveChild(this);
previousParent.OnPositionChanged -= RecalculatePosition;
previousParent.OnScaleChanged -= RecalculateScale;
previousParent.OnRotationChanged -= RecalculateRotation;
previousParent.OnParentChanged -= NotifyChildrenOnParentChange;
}
Parent = transform;
if (transform is not null)
{
transform.AddChild(this);
transform.OnPositionChanged += RecalculatePosition;
transform.OnScaleChanged += RecalculateScale;
transform.OnRotationChanged += RecalculateRotation;
transform.OnParentChanged += NotifyChildrenOnParentChange;
}
UpdateLocalPosition();
UpdateLocalScale();
UpdateLocalRotation();
OnParentChanged?.Invoke(this, previousParent);
}
public void AddChild(ITransform transform)
{
if (_children.Contains(transform))
return;
_children.Add(transform);
transform.SetParent(this);
OnChildrenAdded?.Invoke(this, transform);
}
public void RemoveChild(ITransform transform)
{
if (!_children.Remove(transform))
return;
transform.SetParent(null);
OnChildrenRemoved?.Invoke(this, transform);
}
public IEnumerator<ITransform> GetEnumerator() => _children.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => _children.GetEnumerator();
private void NotifyChildrenOnParentChange(ITransform transform, ITransform? previousParent)
{
// TODO No idea how logical this is to propagate this to the children the way I'm doing right now.
// I was originally gonna just call `child.OnParentChanged?.Invoke(child, child.Parent);` but seems an unnecessary call too?
foreach (var child in Children) // TODO CHECK ERRORS
child.SetParent(this);
}
private void RecalculatePosition(ITransform _)
{
if (Parent is null)
return;
UpdatePosition();
OnPositionChanged?.Invoke(this);
}
private void RecalculateScale(ITransform _)
{
if (Parent is null)
return;
UpdateScale();
OnScaleChanged?.Invoke(this);
}
private void RecalculateRotation(ITransform _)
{
if (Parent is null)
return;
UpdatePosition();
UpdateRotation();
OnPositionChanged?.Invoke(this);
OnRotationChanged?.Invoke(this);
}
private void UpdateLocalPosition()
{
if (Parent is null)
_localPosition = Position;
else
_localPosition = Parent.Position.FromTo(Position).Scale(Parent.Scale);
}
private void UpdateLocalScale()
{
if (Parent is null)
_localScale = Scale;
else
_localScale = Scale.Scale(new(1f / Parent.Scale.X, 1f / Parent.Scale.Y));
}
private void UpdateLocalRotation()
{
if (Parent is null)
_localRotation = Rotation;
else
_localRotation = Rotation - Parent.Rotation;
}
private void UpdatePosition()
{
if (Parent is null)
_position = LocalPosition.Rotate(0f * Math.DegreeToRadian);
else
_position = Parent.Position + LocalPosition.Scale(new(Parent.Scale.X, Parent.Scale.Y)).Rotate(Parent.Rotation * Math.DegreeToRadian);
}
private void UpdateScale()
{
if (Parent is null)
_scale = LocalScale;
else
_scale = Vector2D.Scale(Parent.Scale, LocalScale);
}
private void UpdateRotation()
{
if (Parent is null)
_rotation = LocalRotation;
else
_rotation = Parent.Rotation + LocalRotation;
}
public bool Assign(IGameObject gameObject)
{
if (GameObject is not null && GameObject.IsInitialized)
return false;
GameObject = gameObject;
OnGameObjectAssigned?.Invoke(this);
return true;
}
public bool Unassign()
{
if (GameObject is not null && GameObject.IsInitialized)
return false;
GameObject = null!;
OnUnassigned?.Invoke(this);
return true;
}
}

11
Engine.Input/Abstract/IButtonInputs.cs
View File

@ -4,12 +4,11 @@ namespace Syntriax.Engine.Input;
public interface IButtonInputs<T> : IAssignableStateEnable
{
void RegisterOnPress(T button, ButtonCallbackDelegate callback);
void UnregisterOnPress(T button, ButtonCallbackDelegate callback);
void RegisterOnRelease(T button, ButtonCallbackDelegate callback);
void UnregisterOnRelease(T button, ButtonCallbackDelegate callback);
void RegisterOnPress(T button, Action<IButtonInputs<T>, T> callback);
void UnregisterOnPress(T button, Action<IButtonInputs<T>, T> callback);
void RegisterOnRelease(T button, Action<IButtonInputs<T>, T> callback);
void UnregisterOnRelease(T button, Action<IButtonInputs<T>, T> callback);
bool IsPressed(T button);
delegate void ButtonCallbackDelegate(IButtonInputs<T> buttonInputs, T button);
bool WasPressed(T button);
}

16
Engine.Physics2D/Abstract/ICollider2D.cs
View File

@ -1,3 +1,5 @@
using System;
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Physics2D.Abstract;
@ -10,17 +12,17 @@ public interface ICollider2D : IBehaviour, IAssignableTransform
/// <summary>
/// Event triggered when a collision is detected.
/// </summary>
event OnCollisionDetectedDelegate? OnCollisionDetected;
Action<ICollider2D, CollisionDetectionInformation>? OnCollisionDetected { get; set; }
/// <summary>
/// Event triggered when a collision is resolved.
/// </summary>
event OnCollisionResolvedDelegate? OnCollisionResolved;
Action<ICollider2D, CollisionDetectionInformation>? OnCollisionResolved { get; set; }
/// <summary>
/// Event triggered when another <see cref="ICollider2D"/> triggers this <see cref="ICollider2D"/>.
/// </summary>
event OnTriggeredDelegate? OnTriggered;
Action<ICollider2D, ICollider2D>? OnTriggered { get; set; }
/// <summary>
/// The <see cref="IRigidBody2D"/> associated with the <see cref="ICollider2D"/>.
@ -36,12 +38,4 @@ public interface ICollider2D : IBehaviour, IAssignableTransform
/// Recalculates <see cref="ICollider2D"/> properties.
/// </summary>
void Recalculate();
void Detect(CollisionDetectionInformation collisionDetectionInformation);
void Resolve(CollisionDetectionInformation collisionDetectionInformation);
void Trigger(ICollider2D initiator);
delegate void OnCollisionDetectedDelegate(ICollider2D sender, CollisionDetectionInformation collisionDetectionInformation);
delegate void OnCollisionResolvedDelegate(ICollider2D sender, CollisionDetectionInformation collisionDetectionInformation);
delegate void OnTriggeredDelegate(ICollider2D sender, ICollider2D initiatorCollider);
}

13
Engine.Physics2D/Abstract/IPhysicsEngine2D.cs
View File

@ -5,16 +5,6 @@ namespace Syntriax.Engine.Physics2D.Abstract;
/// </summary>
public interface IPhysicsEngine2D
{
/// <summary>
/// Event triggered when the <see cref="IPhysicsEngine2D"/> has done a single physics iteration.
/// </summary>
event OnPhysicsIterationDelegate? OnPhysicsIteration;
/// <summary>
/// Event triggered when the <see cref="IPhysicsEngine2D"/> has done a full physics step/>.
/// </summary>
event OnPhysicsStepDelegate? OnPhysicsStep;
/// <summary>
/// The number of iterations the <see cref="IPhysicsEngine2D"/> performs per step.
/// </summary>
@ -25,7 +15,4 @@ public interface IPhysicsEngine2D
/// </summary>
/// <param name="deltaTime">The time step.</param>
void Step(float deltaTime);
delegate void OnPhysicsIterationDelegate(IPhysicsEngine2D sender, float iterationDeltaTime);
delegate void OnPhysicsStepDelegate(IPhysicsEngine2D sender, float stepDeltaTime);
}

15
Engine.Physics2D/Abstract/IPhysicsUpdate.cs
View File

@ -1,15 +0,0 @@
using Syntriax.Engine.Core.Abstract;
namespace Syntriax.Engine.Physics2D.Abstract;
/// <summary>
/// Represents a <see cref="IBehaviour"/> that listens to physics simulation update phase.
/// </summary>
public interface IPhysicsUpdate : IBehaviour
{
/// <summary>
/// Updates the physics state of the object based on the elapsed time since the last update.
/// </summary>
/// <param name="delta">The time elapsed since the last physics update, typically in seconds.</param>
void PhysicsUpdate(float delta);
}

24
Engine.Physics2D/Collider2DBehaviourBase.cs
View File

@ -1,14 +1,16 @@
using System;
using Syntriax.Engine.Core;
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Physics2D.Abstract;
namespace Syntriax.Engine.Physics2D;
public abstract class Collider2DBehaviourBase : Behaviour, ICollider2D
public abstract class Collider2DBehaviourBase : BehaviourOverride, ICollider2D
{
public event ICollider2D.OnCollisionDetectedDelegate? OnCollisionDetected = null;
public event ICollider2D.OnCollisionResolvedDelegate? OnCollisionResolved = null;
public event ICollider2D.OnTriggeredDelegate? OnTriggered = null;
public Action<ICollider2D, CollisionDetectionInformation>? OnCollisionDetected { get; set; } = null;
public Action<ICollider2D, CollisionDetectionInformation>? OnCollisionResolved { get; set; } = null;
public Action<ICollider2D, ICollider2D>? OnTriggered { get; set; } = null;
protected bool NeedsRecalculation { get; private set; } = true;
@ -18,7 +20,7 @@ public abstract class Collider2DBehaviourBase : Behaviour, ICollider2D
public bool IsTrigger { get; set; } = false;
ITransform IAssignableTransform.Transform => Transform;
public event IAssignableTransform.OnTransformAssignedDelegate? OnTransformAssigned { add => GameObject.OnTransformAssigned += value; remove => GameObject.OnTransformAssigned -= value; }
Action<IAssignableTransform>? IAssignableTransform.OnTransformAssigned { get => GameObject.OnTransformAssigned; set => GameObject.OnTransformAssigned = value; }
bool IAssignableTransform.Assign(ITransform transform) => GameObject.Assign(transform);
@ -35,7 +37,7 @@ public abstract class Collider2DBehaviourBase : Behaviour, ICollider2D
protected override void OnInitialize()
{
BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
BehaviourController.TryGetBehaviour(out _rigidBody2D);
BehaviourController.OnBehaviourAdded += OnBehaviourAddedToController;
BehaviourController.OnBehaviourRemoved += OnBehaviourRemovedFromController;
@ -43,12 +45,6 @@ public abstract class Collider2DBehaviourBase : Behaviour, ICollider2D
Transform.OnPositionChanged += SetNeedsRecalculation;
Transform.OnRotationChanged += SetNeedsRecalculation;
Transform.OnScaleChanged += SetNeedsRecalculation;
Transform.OnParentChanged += UpdateRigidBody2D;
}
private void UpdateRigidBody2D(ITransform _1, ITransform? _2)
{
BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
}
private void OnBehaviourAddedToController(IBehaviourController _, IBehaviour behaviour)
@ -74,8 +70,4 @@ public abstract class Collider2DBehaviourBase : Behaviour, ICollider2D
Transform.OnPositionChanged -= SetNeedsRecalculation;
Transform.OnRotationChanged -= SetNeedsRecalculation;
}
public void Detect(CollisionDetectionInformation collisionDetectionInformation) => OnCollisionDetected?.Invoke(this, collisionDetectionInformation);
public void Resolve(CollisionDetectionInformation collisionDetectionInformation) => OnCollisionResolved?.Invoke(this, collisionDetectionInformation);
public void Trigger(ICollider2D initiator) => OnTriggered?.Invoke(this, initiator);
}

10
Engine.Physics2D/CollisionDetectionInformation.cs
View File

@ -6,16 +6,14 @@ namespace Syntriax.Engine.Physics2D;
[System.Diagnostics.DebuggerDisplay("Normal: {Normal.ToString(), nq}, Penetration: {Penetration}")]
public readonly struct CollisionDetectionInformation
(
ICollider2D Detector,
ICollider2D Detected,
ICollider2D Left,
ICollider2D Right,
Vector2D Normal,
float Penetration
)
{
public ICollider2D Detector { get; init; } = Detector;
public ICollider2D Detected { get; init; } = Detected;
public ICollider2D Left { get; init; } = Left;
public ICollider2D Right { get; init; } = Right;
public Vector2D Normal { get; init; } = Normal;
public float Penetration { get; init; } = Penetration;
public CollisionDetectionInformation Reverse() => new(Detected, Detector, -Normal, Penetration);
}

6
Engine.Physics2D/CollisionDetector2D.cs
View File

@ -55,7 +55,7 @@ public class CollisionDetector2D : ICollisionDetector2D
if (!leftProjection.Overlaps(rightProjection, out float depth))
return false;
if (collisionInformation.Detector is null || Math.Abs(collisionInformation.Penetration) > Math.Abs(depth))
if (collisionInformation.Left is null || Math.Abs(collisionInformation.Penetration) > Math.Abs(depth))
collisionInformation = new(left, right, projectionVector, depth);
}
@ -79,7 +79,7 @@ public class CollisionDetector2D : ICollisionDetector2D
if (!shapeProjection.Overlaps(circleProjection, out float depth))
return false;
if (collisionInformation.Detector is null || Math.Abs(collisionInformation.Penetration) > Math.Abs(depth))
if (collisionInformation.Left is null || Math.Abs(collisionInformation.Penetration) > Math.Abs(depth))
collisionInformation = new(shapeCollider, circleCollider, projectionVector, depth);
}
@ -92,7 +92,7 @@ public class CollisionDetector2D : ICollisionDetector2D
if (!shapeProjection.Overlaps(circleProjection, out float depth))
return false;
if (collisionInformation.Detector is null || Math.Abs(collisionInformation.Penetration) > Math.Abs(depth))
if (collisionInformation.Left is null || Math.Abs(collisionInformation.Penetration) > Math.Abs(depth))
collisionInformation = new(shapeCollider, circleCollider, shapeToCircleProjectionVector, depth);
}

8
Engine.Physics2D/CollisionResolver2D.cs
View File

@ -9,8 +9,8 @@ public class CollisionResolver2D : ICollisionResolver2D
{
Vector2D displacementVector = collisionInformation.Normal * collisionInformation.Penetration;
ICollider2D left = collisionInformation.Detector;
ICollider2D right = collisionInformation.Detected;
ICollider2D left = collisionInformation.Left;
ICollider2D right = collisionInformation.Right;
bool isLeftStatic = left.RigidBody2D?.IsStatic ?? true;
bool isRightStatic = right.RigidBody2D?.IsStatic ?? true;
@ -38,7 +38,7 @@ public class CollisionResolver2D : ICollisionResolver2D
left.Recalculate();
right.Recalculate();
left.Resolve(collisionInformation);
right.Resolve(collisionInformation);
left.OnCollisionResolved?.Invoke(collisionInformation.Left, collisionInformation);
right.OnCollisionResolved?.Invoke(right, collisionInformation);
}
}

30
Engine.Physics2D/Physics2D.cs
View File

@ -1,33 +1,13 @@
using System;
using Syntriax.Engine.Core;
using Syntriax.Engine.Physics2D;
using Syntriax.Engine.Physics2D.Primitives;
namespace Engine.Physics2D;
public static partial class Physics2D
{
public static bool Overlaps(this Shape shape, Vector2D point) => Overlaps(shape, point, out var _);
public static bool Overlaps(this Shape shape, Vector2D point, out float depth)
{
depth = float.MaxValue;
var vertices = shape.Vertices;
int count = vertices.Count;
for (int indexProjection = 0; indexProjection < count; indexProjection++)
{
Vector2D projectionVector = vertices[indexProjection].FromTo(vertices[(indexProjection + 1) % count]).Perpendicular().Normalized;
Projection shapeProjection = shape.ToProjection(projectionVector);
float projectedPoint = point.Dot(projectionVector);
if (shapeProjection.Max < projectedPoint || shapeProjection.Min > projectedPoint)
return false;
depth = Math.Min(depth, Math.Abs(Math.AbsMin(shapeProjection.Max - projectedPoint, shapeProjection.Min - projectedPoint)));
}
return true;
}
public static bool Overlaps(this Circle left, Circle right)
{
float distanceSquared = left.Center.FromTo(right.Center).LengthSquared();
@ -47,7 +27,7 @@ public static partial class Physics2D
normal = distanceVector.Normalized;
if (isOverlapping)
depth = Math.Sqrt(radiusSumSquared - distanceSquared);
depth = MathF.Sqrt(radiusSumSquared - distanceSquared);
return isOverlapping;
}
@ -64,7 +44,7 @@ public static partial class Physics2D
normal = distanceVector.Normalized;
if (isOverlapping)
depth = Math.Sqrt(radiusSquared - distanceSquared);
depth = MathF.Sqrt(radiusSquared - distanceSquared);
return isOverlapping;
}

67
Engine.Physics2D/PhysicsCoroutineManager.cs
View File

@ -1,67 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using Syntriax.Engine.Core;
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Physics2D.Abstract;
namespace Engine.Physics2D;
public class PhysicsCoroutineManager : HierarchyObjectBase
{
private readonly List<IEnumerator> enumerators = [];
private IPhysicsEngine2D? physicsEngine = null;
public IEnumerator CreateCoroutine(IEnumerator enumerator)
{
enumerators.Add(enumerator);
return enumerator;
}
public void StopCoroutine(IEnumerator enumerator)
{
enumerators.Remove(enumerator);
}
protected override void OnEnteringHierarchy(IGameManager gameManager)
{
physicsEngine = gameManager.HierarchyObjects.FindObject<IPhysicsEngine2D>();
if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
foundPhysicsEngine.OnPhysicsStep += OnPhysicsStep;
else
gameManager.OnUpdate += OnUpdate;
}
private void OnPhysicsStep(IPhysicsEngine2D sender, float stepDeltaTime)
{
for (int i = enumerators.Count - 1; i >= 0; i--)
{
if (enumerators[i].Current is ICoroutineYield coroutineYield && coroutineYield.Yield())
continue;
if (!enumerators[i].MoveNext())
enumerators.RemoveAt(i);
}
}
protected override void OnExitingHierarchy(IGameManager gameManager)
{
if (physicsEngine is IPhysicsEngine2D existingPhysicsEngine)
existingPhysicsEngine.OnPhysicsStep -= OnPhysicsStep;
gameManager.OnUpdate -= OnUpdate;
}
private void OnUpdate(IGameManager sender, EngineTime time)
{
if (GameManager is not IGameManager gameManager)
return;
physicsEngine = gameManager.HierarchyObjects.FindObject<IPhysicsEngine2D>();
if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
{
foundPhysicsEngine.OnPhysicsStep += OnPhysicsStep;
gameManager.OnUpdate -= OnUpdate;
}
}
}

24
Engine.Physics2D/PhysicsEngine2D.cs
View File

@ -1,5 +1,6 @@
using System.Collections.Generic;
using Syntriax.Engine.Core;
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Physics2D.Abstract;
@ -7,9 +8,6 @@ namespace Syntriax.Engine.Physics2D;
public class PhysicsEngine2D : IPhysicsEngine2D
{
public event IPhysicsEngine2D.OnPhysicsIterationDelegate? OnPhysicsIteration = null;
public event IPhysicsEngine2D.OnPhysicsStepDelegate? OnPhysicsStep = null;
private readonly List<IRigidBody2D> rigidBodies = new(32);
private readonly List<ICollider2D> colliders = new(64);
@ -74,7 +72,7 @@ public class PhysicsEngine2D : IPhysicsEngine2D
if (bothCollidersAreTriggers)
continue;
bool bothCollidersAreStatic = (colliderX.RigidBody2D?.IsStatic ?? true) && (colliderY.RigidBody2D?.IsStatic ?? true);
bool bothCollidersAreStatic = colliderX.RigidBody2D?.IsStatic ?? true && colliderX.RigidBody2D?.IsStatic == colliderY.RigidBody2D?.IsStatic;
if (bothCollidersAreStatic)
continue;
@ -82,33 +80,23 @@ public class PhysicsEngine2D : IPhysicsEngine2D
{
if (colliderX.IsTrigger)
{
colliderX.Trigger(colliderY);
colliderX.OnTriggered?.Invoke(colliderX, colliderY);
continue;
}
else if (colliderY.IsTrigger)
{
colliderY.Trigger(colliderY);
colliderY.OnTriggered?.Invoke(colliderY, colliderY);
continue;
}
if (information.Detector == colliderX)
{
colliderX.Detect(information);
colliderY.Detect(information.Reverse());
}
else
{
colliderX.Detect(information.Reverse());
colliderY.Detect(information);
}
colliderX.OnCollisionDetected?.Invoke(colliderX, information);
colliderY.OnCollisionDetected?.Invoke(colliderY, information);
collisionResolver?.Resolve(information);
}
}
}
OnPhysicsIteration?.Invoke(this, intervalDeltaTime);
}
OnPhysicsStep?.Invoke(this, deltaTime);
}
private static void StepRigidBody(IRigidBody2D rigidBody, float intervalDeltaTime)

100
Engine.Physics2D/PhysicsEngine2DCollector.cs → Engine.Physics2D/PhysicsEngine2DCacher.cs
View File

@ -1,25 +1,28 @@
using System;
using Syntriax.Engine.Core;
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Physics2D.Abstract;
namespace Syntriax.Engine.Physics2D;
public class PhysicsEngine2DCollector : HierarchyObjectBase, IPhysicsEngine2D
public class PhysicsEngine2DCacher : IPhysicsEngine2D, IAssignableGameManager
{
public event IPhysicsEngine2D.OnPhysicsIterationDelegate? OnPhysicsIteration = null;
public event IPhysicsEngine2D.OnPhysicsStepDelegate? OnPhysicsStep = null;
public Action<IAssignable>? OnUnassigned { get; set; } = null;
public Action<IAssignableGameManager>? OnGameManagerAssigned { get; set; } = null;
private int _iterationPerStep = 1;
protected readonly ICollisionDetector2D collisionDetector = null!;
protected readonly ICollisionResolver2D collisionResolver = null!;
protected BehaviourCollector<IRigidBody2D> rigidBodyCollector = new();
protected BehaviourCollector<ICollider2D> colliderCollector = new();
protected BehaviourCollector<IPhysicsUpdate> physicsUpdateCollector = new();
protected BehaviourCacher<IRigidBody2D> rigidBodyCacher = new();
protected BehaviourCacher<ICollider2D> colliderCacher = new();
public int IterationPerStep { get => _iterationPerStep; set => _iterationPerStep = value < 1 ? 1 : value; }
public IGameManager GameManager { get; private set; } = null!;
public void Step(float deltaTime)
{
@ -28,23 +31,23 @@ public class PhysicsEngine2DCollector : HierarchyObjectBase, IPhysicsEngine2D
for (int iterationIndex = 0; iterationIndex < IterationPerStep; iterationIndex++)
{
// Can Parallel
foreach (var rigidBody in rigidBodyCollector)
foreach (var rigidBody in rigidBodyCacher)
StepRigidBody(rigidBody, intervalDeltaTime);
// Can Parallel
foreach (var collider in colliderCollector)
foreach (var collider in colliderCacher)
collider.Recalculate();
// Can Parallel
for (int x = 0; x < colliderCollector.Behaviours.Count; x++)
for (int x = 0; x < colliderCacher.Behaviours.Count; x++)
{
ICollider2D? colliderX = colliderCollector.Behaviours[x];
ICollider2D? colliderX = colliderCacher.Behaviours[x];
if (!colliderX.IsActive)
return;
for (int y = x + 1; y < colliderCollector.Behaviours.Count; y++)
for (int y = x + 1; y < colliderCacher.Behaviours.Count; y++)
{
ICollider2D? colliderY = colliderCollector.Behaviours[y];
ICollider2D? colliderY = colliderCacher.Behaviours[y];
if (!colliderY.IsActive)
return;
@ -56,7 +59,7 @@ public class PhysicsEngine2DCollector : HierarchyObjectBase, IPhysicsEngine2D
if (bothCollidersAreTriggers)
continue;
bool bothCollidersAreStatic = (colliderX.RigidBody2D?.IsStatic ?? true) && (colliderY.RigidBody2D?.IsStatic ?? true);
bool bothCollidersAreStatic = colliderX.RigidBody2D?.IsStatic ?? true && colliderX.RigidBody2D?.IsStatic == colliderY.RigidBody2D?.IsStatic;
if (bothCollidersAreStatic)
continue;
@ -64,38 +67,23 @@ public class PhysicsEngine2DCollector : HierarchyObjectBase, IPhysicsEngine2D
{
if (colliderX.IsTrigger)
{
colliderX.Trigger(colliderY);
colliderX.OnTriggered?.Invoke(colliderX, colliderY);
continue;
}
else if (colliderY.IsTrigger)
{
colliderY.Trigger(colliderY);
colliderY.OnTriggered?.Invoke(colliderY, colliderY);
continue;
}
if (information.Detector == colliderX)
{
colliderX.Detect(information);
colliderY.Detect(information.Reverse());
}
else
{
colliderX.Detect(information.Reverse());
colliderY.Detect(information);
}
colliderX.OnCollisionDetected?.Invoke(colliderX, information);
colliderY.OnCollisionDetected?.Invoke(colliderY, information);
collisionResolver?.Resolve(information);
}
}
}
OnPhysicsIteration?.Invoke(this, intervalDeltaTime);
}
foreach (IPhysicsUpdate physicsUpdate in physicsUpdateCollector)
physicsUpdate.PhysicsUpdate(deltaTime);
OnPhysicsStep?.Invoke(this, deltaTime);
}
private static void StepRigidBody(IRigidBody2D rigidBody, float intervalDeltaTime)
@ -106,27 +94,55 @@ public class PhysicsEngine2DCollector : HierarchyObjectBase, IPhysicsEngine2D
rigidBody.Transform.Position += rigidBody.Velocity * intervalDeltaTime;
rigidBody.Transform.Rotation += rigidBody.AngularVelocity * intervalDeltaTime;
}
protected override void OnEnteringHierarchy(IGameManager gameManager)
public bool Assign(IGameManager gameManager)
{
physicsUpdateCollector.Assign(gameManager);
colliderCollector.Assign(gameManager);
rigidBodyCollector.Assign(gameManager);
if (GameManager is not null)
return false;
colliderCacher.Assign(gameManager);
rigidBodyCacher.Assign(gameManager);
GameManager = gameManager;
OnGameManagerAssigned?.Invoke(this);
return true;
}
protected override void OnExitingHierarchy(IGameManager gameManager)
public bool Unassign()
{
physicsUpdateCollector.Unassign();
colliderCollector.Unassign();
rigidBodyCollector.Unassign();
if (GameManager is null)
return false;
colliderCacher.Unassign();
rigidBodyCacher.Unassign();
GameManager = null!;
OnUnassigned?.Invoke(this);
return true;
}
public PhysicsEngine2DCollector()
public PhysicsEngine2DCacher()
{
collisionDetector = new CollisionDetector2D();
collisionResolver = new CollisionResolver2D();
}
public PhysicsEngine2DCollector(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
public PhysicsEngine2DCacher(IGameManager gameManager)
{
Assign(gameManager);
collisionDetector = new CollisionDetector2D();
collisionResolver = new CollisionResolver2D();
}
public PhysicsEngine2DCacher(IGameManager gameManager, ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
{
Assign(gameManager);
this.collisionDetector = collisionDetector;
this.collisionResolver = collisionResolver;
}
public PhysicsEngine2DCacher(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
{
this.collisionDetector = collisionDetector;
this.collisionResolver = collisionResolver;

2
Engine.Physics2D/Primitives/Circle.cs
View File

@ -69,7 +69,7 @@ public readonly struct Circle(Vector2D center, float radius)
/// Transforms the <see cref="Circle"/> by the specified <see cref="ITransform"/>.
/// </summary>
public static Circle TransformCircle(ITransform transform, Circle circle)
=> new(transform.TransformVector2D(circle.Center), circle.Radius * (transform.Scale.Magnitude / Vector2D.One.Magnitude));
=> new(transform.TransformVector2D(circle.Center), circle.Radius * transform.Scale.Magnitude);
/// <summary>
/// Checks if two <see cref="Circle"/>s are approximately equal.

34
Engine.Physics2D/Primitives/Line.cs
View File

@ -202,40 +202,6 @@ public readonly struct Line(Vector2D from, Vector2D to)
/// </summary>
public static class LineExtensions
{
/// <summary>
/// Linearly interpolates between the two endpoints of the <see cref="Line"/> segment using parameter 't'.
/// </summary>
public static Vector2D Lerp(this Line line, float t) => Line.Lerp(line, t);
/// <summary>
/// The equation of the <see cref="Line"/> defined by this <see cref="Line"/> segment.
/// </summary>
public static LineEquation ToLineEquation(this Line line) => Line.GetLineEquation(line);
/// <summary>
/// Determines whether the specified <see cref="Vector2D"/> lies on the <see cref="Line"/>.
/// </summary>
public static bool Intersects(this Line line, Vector2D point) => Line.Intersects(line, point);
/// <summary>
/// Calculates the parameter 't' representing the point's position on the <see cref="Line"/> segment.
/// </summary>
public static float GetT(this Line line, Vector2D point) => Line.GetT(line, point);
/// <summary>
/// Checks if the <see cref="Line"/> segment intersects with another <see cref="Line"/> segment.
/// </summary>
public static bool Intersects(this Line left, Line right) => Line.Intersects(left, right);
/// <summary>
/// Determines whether two <see cref="Line"/> segments intersect.
/// </summary>
public static bool Intersects(this Line left, Line right, [NotNullWhen(returnValue: true)] out Vector2D? point) => Line.Intersects(left, right, out point);
/// <summary>
/// Checks if two <see cref="Line"/>s are approximately equal.
/// </summary>

6
Engine.Physics2D/RigidBody2D.cs
View File

@ -1,12 +1,14 @@
using System;
using Syntriax.Engine.Core;
using Syntriax.Engine.Core.Abstract;
using Syntriax.Engine.Physics2D.Abstract;
namespace Syntriax.Engine.Physics2D;
public class RigidBody2D : Behaviour, IRigidBody2D
public class RigidBody2D : BehaviourOverride, IRigidBody2D
{
event IAssignableTransform.OnTransformAssignedDelegate? IAssignableTransform.OnTransformAssigned { add => GameObject.OnTransformAssigned += value; remove => GameObject.OnTransformAssigned -= value; }
public Action<IAssignableTransform>? OnTransformAssigned { get => GameObject.OnTransformAssigned; set => GameObject.OnTransformAssigned = value; }
private const float LOWEST_ALLOWED_MASS = 0.00001f;
private float _mass = 1f;