pax_global_header00006660000000000000000000000064151272723630014522gustar00rootroot0000000000000052 comment=82c6470c48207557211e6adf34bc38d3714dae4a SharpEngine.Aether-1.6.0/000077500000000000000000000000001512727236300151405ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/.github/000077500000000000000000000000001512727236300165005ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/.github/workflows/000077500000000000000000000000001512727236300205355ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/.github/workflows/build.yml000066400000000000000000000023271512727236300223630ustar00rootroot00000000000000name: SonarCloud on: push: branches: - master pull_request: types: [opened, synchronize, reopened] jobs: build: name: Build and analyze runs-on: ubuntu-latest steps: - name: Set up JDK 17 uses: actions/setup-java@v3 with: java-version: 17 distribution: 'zulu' - uses: actions/checkout@v3 with: fetch-depth: 0 - name: Setup .NET uses: actions/setup-dotnet@v3 - name: Install SonarCloud scanner if: steps.cache-sonar-scanner.outputs.cache-hit != 'true' run: | dotnet tool install --global dotnet-sonarscanner - name: Build and analyze env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # Needed to get PR information, if any SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} run: | dotnet-sonarscanner begin /k:"SharpEngine_SharpEngine.Aether" /o:"sharpengine" /d:sonar.token="${{ secrets.SONAR_TOKEN }}" /d:sonar.host.url="https://sonarcloud.io" dotnet restore dotnet build SharpEngine.AetherPhysics/SharpEngine.AetherPhysics.csproj -c Release dotnet-sonarscanner end /d:sonar.token="${{ secrets.SONAR_TOKEN }}"SharpEngine.Aether-1.6.0/.github/workflows/dotnet.yml000066400000000000000000000047511512727236300225640ustar00rootroot00000000000000# This workflow will build a .NET project # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net name: .NET on: workflow_dispatch: # Allow running the workflow manually from the GitHub UI release: types: - published # Run the workflow when a new GitHub release is published env: DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1 DOTNET_NOLOGO: true NuGetDirectory: ${{ github.workspace}}/nuget defaults: run: shell: pwsh jobs: create_nuget: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - name: Setup .NET uses: actions/setup-dotnet@v4 - name: Restore run: dotnet restore - name: Build run: dotnet build SharpEngine.Aether/SharpEngine.Aether.csproj -c Release - name: Pack Nuget run: dotnet pack SharpEngine.Aether/SharpEngine.Aether.csproj -c Release --no-build --output ${{ env.NuGetDirectory }} - uses: actions/upload-artifact@v4 with: name: nuget if-no-files-found: error retention-days: 7 path: ${{ env.NuGetDirectory }}/*.nupkg validate_nuget: runs-on: ubuntu-latest needs: [ create_nuget ] steps: - name: Setup .NET uses: actions/setup-dotnet@v4 - uses: actions/download-artifact@v4 with: name: nuget path: ${{ env.NuGetDirectory }} - name: Install nuget validator run: dotnet tool update Meziantou.Framework.NuGetPackageValidation.Tool --global - name: Validate package run: meziantou.validate-nuget-package (Get-ChildItem "${{ env.NuGetDirectory }}/*.nupkg") continue-on-error: true run_test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Setup .NET uses: actions/setup-dotnet@v4 - name: Run tests run: dotnet test --configuration Release deploy: runs-on: ubuntu-latest needs: [ validate_nuget, run_test ] steps: - uses: actions/download-artifact@v4 with: name: nuget path: ${{ env.NuGetDirectory }} - name: Setup .NET uses: actions/setup-dotnet@v4 - name: Publish NuGet package run: | foreach($file in (Get-ChildItem "${{ env.NuGetDirectory }}" -Recurse -Include *.nupkg)) { dotnet nuget push $file --api-key "${{ secrets.NUGET_APIKEY }}" --source https://api.nuget.org/v3/index.json --skip-duplicate } SharpEngine.Aether-1.6.0/.gitignore000066400000000000000000000000751512727236300171320ustar00rootroot00000000000000bin/ obj/ /packages/ riderModule.iml /_ReSharper.Caches/ .vs/SharpEngine.Aether-1.6.0/.idea/000077500000000000000000000000001512727236300161205ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/.idea/.idea.SharpEngine.Aether/000077500000000000000000000000001512727236300225115ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/.idea/.idea.SharpEngine.Aether/.idea/000077500000000000000000000000001512727236300234715ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/.idea/.idea.SharpEngine.Aether/.idea/.gitignore000066400000000000000000000004371512727236300254650ustar00rootroot00000000000000# Default ignored files /shelf/ /workspace.xml # Rider ignored files /contentModel.xml /modules.xml /.idea.SharpEngine.Aether.iml /projectSettingsUpdater.xml # Editor-based HTTP Client requests /httpRequests/ # Datasource local storage ignored files /dataSources/ /dataSources.local.xml SharpEngine.Aether-1.6.0/.idea/.idea.SharpEngine.Aether/.idea/indexLayout.xml000066400000000000000000000003061512727236300265170ustar00rootroot00000000000000 SharpEngine.Aether-1.6.0/.idea/.idea.SharpEngine.Aether/.idea/misc.xml000066400000000000000000000003241512727236300251450ustar00rootroot00000000000000 SharpEngine.Aether-1.6.0/.idea/.idea.SharpEngine.Aether/.idea/vcs.xml000066400000000000000000000002471512727236300250110ustar00rootroot00000000000000 SharpEngine.Aether-1.6.0/CHANGELOG.md000066400000000000000000000032141512727236300167510ustar00rootroot00000000000000# Changelog ### Légende [+] Add
[\~] Modification
[-] Suppression
[#] Bug Fixes
[.] Others ### V 1.6.0 - 06/01/2025 [+] PhysicsAutoComponent
[\~] PhysicsComponent: SetRotation now takes a float instead of an int
[.] Move Components into the Component folder
[.] Update SharpEngine.Core to 2.5.0
[.] Refactor with Rider ### V 1.5.0 - 12/12/2025 [.] Update Aether.Physics2D to 2.2.0
[.] Update SharpEngine.Core to 2.4.0
[.] Net 10 ### V 1.4.1 - 18/01/2025 [\~] PhysicsControlComponent: Replace pressed keys and buttons with down keys and buttons ### V 1.4.0 - 11/01/2025 [.] Update SharpEngine.Core to 2.0.0 ### V 1.3.2 - 24/11/2024 [+] PhysicsSystem: GetBodyForEntity
[.] Update SharpEngine.Core to 1.9.2 ### V 1.3.1 - 21/11/2024 [#] Fix versions in DebugManager ### V 1.3.0 - 17/11/2024 [.] Add a warning log about rotation with debug draws
[.] Update Aether.Physics2D to 2.1.0
[.] Update SharpEngine.Core to 1.9.0 ### V 1.2.2 - 23/12/2023 [\~] PhysicsComponent: AddRectangleCollision and AddCircleCollision return component
[#] PhysicsComponent: GetPosition returns the wrong position ### V 1.2.1 - 10/12/2023 [+] PhysicsSystem: CreateBody, GetEntityFromBody ### V 1.2.0 - 27/11/2023 [.] SharpEngine.Core: 1.7.2
[.] Refactor with SonarCloud ### V 1.1.0 - 21/11/2023 [.] Update Aether.Physics2D to 2.0.0
[.] Update SharpEngine.Core to 1.6.0
[.] Net 8 ### V 1.0.2 - 14/08/2023 [+] PhysicsSystem: delay param in RemoveBody ### V 1.0.1 - 14/08/2023 [+] PhysicsSystem: RemoveBody ### V 1.0.0 - 14/08/2023 [.] First version (Created from http://github.com/AlexisHuvier/SharpEngine) SharpEngine.Aether-1.6.0/CONTRIBUTING.md000066400000000000000000000017661512727236300174030ustar00rootroot00000000000000# How to contribute SharpEngine is a little project and I am happy to see that people want to contribute to it. So thanks ! To contribute efficiently, there is some things that you can do. ## Reporting bugs, proposing features or improvements You can simply make an issue with the template (soon). ## Contributing pull requests If you want to add your own features / bug fixes, please make sure that : - This features is usable in real projets. - You talked with other developer if somebody work on that already. - Your work follows code style and git guidelines If you want to add a feature / bug fixes, you can find some in issues of this projects. ### Git Guidelines - Try to make simple PRs (or issues) which target one specific topic. - Try to keep a clean git history. - Try to keep relevent and short branches names. Use dashes to separate words. - Try you work before pushing. ### Code Style Guidelines - Use CSharpier to format your work. It's already installed in every SharpEngine's Project. SharpEngine.Aether-1.6.0/README.md000066400000000000000000000002661512727236300164230ustar00rootroot00000000000000# SharpEngine.Aether Aether Package of SharpEngine - C# 2D Game Engine ## Installation, Download, Usage *Coming Soon* ## Dependencies - Net8 - SharpEngine.Core - Aether Physics SharpEngine.Aether-1.6.0/SharpEngine.Aether.sln000066400000000000000000000024231512727236300212710ustar00rootroot00000000000000 Microsoft Visual Studio Solution File, Format Version 12.00 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpEngine.AetherPhysics", "SharpEngine.AetherPhysics\SharpEngine.AetherPhysics.csproj", "{90C3CDD5-9935-47BA-A146-B234F6A5207C}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Testing", "Testing\Testing.csproj", "{93B6C606-DFF3-4AC4-8A2B-CEF3D623E9A4}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {90C3CDD5-9935-47BA-A146-B234F6A5207C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {90C3CDD5-9935-47BA-A146-B234F6A5207C}.Debug|Any CPU.Build.0 = Debug|Any CPU {90C3CDD5-9935-47BA-A146-B234F6A5207C}.Release|Any CPU.ActiveCfg = Release|Any CPU {90C3CDD5-9935-47BA-A146-B234F6A5207C}.Release|Any CPU.Build.0 = Release|Any CPU {93B6C606-DFF3-4AC4-8A2B-CEF3D623E9A4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {93B6C606-DFF3-4AC4-8A2B-CEF3D623E9A4}.Debug|Any CPU.Build.0 = Debug|Any CPU {93B6C606-DFF3-4AC4-8A2B-CEF3D623E9A4}.Release|Any CPU.ActiveCfg = Release|Any CPU {93B6C606-DFF3-4AC4-8A2B-CEF3D623E9A4}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection EndGlobal SharpEngine.Aether-1.6.0/SharpEngine.Aether.sln.DotSettings.user000066400000000000000000000014551512727236300245200ustar00rootroot00000000000000 ForceIncludedSharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/000077500000000000000000000000001512727236300221155ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Component/000077500000000000000000000000001512727236300240575ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Component/PhysicsAutoComponent.cs000066400000000000000000000027401512727236300305470ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Component; using SharpEngine.Core.Math; namespace SharpEngine.AetherPhysics.Component { /// /// Represents a physics-enabled auto component designed to integrate physics-based behaviors /// within the SharpEngine framework. This class is intended to provide automated functionality /// for handling physics properties and interactions associated with game objects. /// /// Direction /// Rotation [UsedImplicitly] public class PhysicsAutoComponent(Vec2? direction = null, int rotation = 0): AutoComponent(direction, rotation) { private PhysicsComponent? _physicsComponent; /// public override void Load() { base.Load(); _physicsComponent = Entity?.GetComponentAs(); } /// [UsedImplicitly] public override void Update(float delta) { base.Update(delta); if (_physicsComponent == null) return; _physicsComponent.SetLinearVelocity(Vec2.Zero); if (Direction.Length() != 0) _physicsComponent.SetLinearVelocity(Direction); if(Rotation != 0) _physicsComponent.SetRotation(Rotation * delta + _physicsComponent.GetRotation()); } } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Component/PhysicsComponent.cs000066400000000000000000000314341512727236300277200ustar00rootroot00000000000000using System; using System.Collections.Generic; using JetBrains.Annotations; using SharpEngine.AetherPhysics.Fixture; using SharpEngine.AetherPhysics.Joint; using SharpEngine.Core.Component; using SharpEngine.Core.Math; using SharpEngine.Core.Renderer; using SharpEngine.Core.Utils; using nkast.Aether.Physics2D.Dynamics; using nkast.Aether.Physics2D.Dynamics.Contacts; using SharpEngine.Core.Manager; namespace SharpEngine.AetherPhysics.Component; /// /// Components which add physics /// /// /// Create a PhysicsComponent /// [UsedImplicitly] public class PhysicsComponent : Core.Component.Component { /// /// Body Physics /// [UsedImplicitly] public Body? Body { get; set; } /// /// Draw debug information /// [UsedImplicitly] public bool DebugDraw { get; set { if (value) DebugManager.Log(LogLevel.Warning, "Debug Physics Draw doesn't take rotation into account."); field = value; } } /// /// Event which be called when collision /// [UsedImplicitly] public EventHandler? CollisionCallback { get; set; } /// /// Event which be called when separation /// [UsedImplicitly] public EventHandler? SeparationCallback { get; set; } private readonly BodyType _bodyType; private readonly List _fixtures = []; private readonly List _joints = []; private readonly bool _fixedRotation; private readonly bool _ignoreGravity; private readonly List> _debugDrawings = []; private readonly List _contacts = []; private TransformComponent? _transform; /// Type of Body /// Ignore Gravity /// Rotation fixed /// Debug Draw public PhysicsComponent( BodyType bodyType = BodyType.Dynamic, bool ignoreGravity = false, bool fixedRotation = false, bool debugDraw = false ) { _bodyType = bodyType; _fixedRotation = fixedRotation; _ignoreGravity = ignoreGravity; DebugDraw = debugDraw; } /// /// Return Position of Body /// /// Body Position [UsedImplicitly] public Vec2 GetPosition() => new(Body!.Position.X * 50, Body.Position.Y * 50); /// /// Define Position of Body /// /// Body Position [UsedImplicitly] public void SetPosition(Vec2 position) => Body!.Position = (position * 0.02f).ToAetherPhysics(); /// /// Return Linear Velocity of Body /// /// Body Linear Velocity public Vec2 GetLinearVelocity() => new(Body!.LinearVelocity.X * 50, Body.LinearVelocity.Y * 50); /// /// Define Linear Velocity of Body /// /// Body Linear Velocity public void SetLinearVelocity(Vec2 velocity) => Body!.LinearVelocity = (velocity * 0.02f).ToAetherPhysics(); /// /// Apply Impulse to Body /// /// Linear Impulse [UsedImplicitly] public void ApplyLinearImpulse(Vec2 impulse) => Body!.ApplyLinearImpulse((impulse * 0.02f).ToAetherPhysics()); /// /// Return Rotation of Body /// /// Body Rotation [UsedImplicitly] public float GetRotation() => Body!.Rotation * 180 / MathHelper.Pi; /// /// Define Rotation of Body /// /// Body Rotation [UsedImplicitly] public void SetRotation(float rotation) => Body!.Rotation = rotation * MathHelper.Pi / 180f; /// /// Add Rectangle Collision /// /// Collision Size /// Collision Offset /// Collision Density /// Collision Restitution /// Collision Friction /// Collision Tag [UsedImplicitly] public PhysicsComponent AddRectangleCollision( Vec2 size, Vec2? offset = null, float density = 1f, float restitution = 0.5f, float friction = 0.5f, FixtureTag tag = FixtureTag.Normal ) { offset ??= Vec2.Zero; var fixture = new FixtureInfo { Density = density, Restitution = restitution, Friction = friction, Type = FixtureType.Rectangle, Parameter = size * 0.02f, Offset = offset * 0.02f, Tag = tag }; _debugDrawings.Add(["rectangle", size, offset]); _fixtures.Add(fixture); return this; } /// /// Add Circle Collision /// /// Collision Radius /// Collision Offset /// Collision Density /// Collision Restitution /// Collision Friction /// Collision Tag [UsedImplicitly] public PhysicsComponent AddCircleCollision( float radius, Vec2? offset = null, float density = 1f, float restitution = 0.5f, float friction = 0.5f, FixtureTag tag = FixtureTag.Normal ) { offset ??= Vec2.Zero; var fixture = new FixtureInfo { Density = density, Restitution = restitution, Friction = friction, Type = FixtureType.Circle, Parameter = radius * 0.02f, Offset = offset * 0.02f, Tag = tag }; _debugDrawings.Add(["circle", radius, offset]); _fixtures.Add(fixture); return this; } /// /// Return if entity is on ground /// /// If is on the ground public bool IsOnGround() { if (GetLinearVelocity().Y != 0) return false; foreach (var contact in _contacts) { contact.GetWorldManifold(out var normal, out _); if (normal.X == 0 && Math.Abs(normal.Y + 1) < 0.001f) return true; } return false; } /// /// Add joint /// /// Joint [UsedImplicitly] public void AddJoint(Joint.Joint joint) => _joints.Add(joint); /// /// Remove Body /// [UsedImplicitly] public void RemoveBody() { if (Body != null) Entity?.Scene?.GetSceneSystem()?.World.Remove(Body); Body = null; } /// public override void Load() { base.Load(); _transform = Entity?.GetComponentAs(); if (Entity == null || _transform == null) return; var body = Entity.Scene?.GetSceneSystem()? .CreateBody(Entity, _transform.Position * 0.02f, MathHelper.ToRadians(_transform.Rotation), _bodyType); if (body == null) return; Body = body; Body.FixedRotation = _fixedRotation; Body.IgnoreGravity = _ignoreGravity; Body.OnCollision += OnCollision; Body.OnSeparation += OnSeparation; } /// public override void Update(float delta) { base.Update(delta); if (Body == null) return; // Create Fixtures foreach (var info in _fixtures) { nkast.Aether.Physics2D.Dynamics.Fixture fixture; switch (info.Type) { case FixtureType.Rectangle: var size = info.Parameter as Vec2; fixture = Body.CreateRectangle( size!.X, size.Y, info.Density, info.Offset.ToAetherPhysics() ); break; case FixtureType.Circle: var radius = Convert.ToSingle(info.Parameter); fixture = Body.CreateCircle( radius, info.Density, info.Offset.ToAetherPhysics() ); break; default: throw new ArgumentException($"Unknown Type of Fixture : {info.Type}"); } fixture.Tag = info.Tag; fixture.Restitution = info.Restitution; fixture.Friction = info.Friction; } _fixtures.Clear(); // Create Joint foreach (var joint in _joints) { switch (joint.Type) { case JointType.Distance: Entity ?.Scene?.GetSceneSystem() ?.World.Add(((DistanceJoint)joint).ToAetherPhysics(Body)); break; case JointType.Revolute: Entity ?.Scene?.GetSceneSystem() ?.World.Add(((RevoluteJoint)joint).ToAetherPhysics(Body)); break; case JointType.Rope: Entity ?.Scene?.GetSceneSystem() ?.World.Add(((RopeJoint)joint).ToAetherPhysics(Body)); break; default: throw new ArgumentException($"Unknown Type of Joint : {joint.Type}"); } } _joints.Clear(); if (_transform == null) return; _transform.LocalPosition = (Body.Position * 50f).ToSharpEngine(); _transform.LocalRotation = (int)MathHelper.ToDegrees(Body.Rotation); } /// public override void Draw() { base.Draw(); if (_transform == null) return; if (!DebugDraw) return; foreach (var drawing in _debugDrawings) { switch ((string)drawing[0]) { case "rectangle": var size = (Vec2)drawing[1]; var offset = (Vec2)drawing[2]; var rect = new Rect( _transform.Position.X + offset.X - size.X / 2, _transform.Position.Y + offset.Y - size.Y / 2, size.X, size.Y ); SERender.DrawRectangleLines( rect, 2, Color.DarkRed, InstructionSource.Entity, int.MaxValue ); break; case "circle": var radius = (float)drawing[1]; var offsetCirc = (Vec2)drawing[2]; SERender.DrawCircleLines( (int)(_transform.Position.X + offsetCirc.X), (int)(_transform.Position.Y + offsetCirc.Y), radius, Color.DarkRed, InstructionSource.Entity, int.MaxValue ); break; } } } private bool OnCollision( nkast.Aether.Physics2D.Dynamics.Fixture sender, nkast.Aether.Physics2D.Dynamics.Fixture other, Contact contact ) { var eventArgs = new PhysicsEventArgs { Sender = sender, Other = other, Contact = contact, Result = true }; CollisionCallback?.Invoke(this, eventArgs); if ( (FixtureTag)sender.Tag == FixtureTag.IgnoreCollisions || (FixtureTag)other.Tag == FixtureTag.IgnoreCollisions ) eventArgs.Result = false; if (eventArgs.Result) _contacts.Add(contact); return eventArgs.Result; } private void OnSeparation( nkast.Aether.Physics2D.Dynamics.Fixture sender, nkast.Aether.Physics2D.Dynamics.Fixture other, Contact contact ) { var eventArgs = new PhysicsEventArgs { Sender = sender, Other = other, Contact = contact, Result = true }; SeparationCallback?.Invoke(this, eventArgs); _contacts.Remove(contact); } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Component/PhysicsControlComponent.cs000066400000000000000000000054421512727236300312610ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Component; using SharpEngine.Core.Input; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; namespace SharpEngine.AetherPhysics.Component; /// /// Physics version of ControlComponent /// /// Create Physics Control Component /// Control Type (FourDirection) /// Speed (300) /// Jump Force (3) /// Use Game Pad (false) /// Game Pad Index (1) [UsedImplicitly] public class PhysicsControlComponent( ControlType controlType = ControlType.FourDirection, int speed = 300, float jumpForce = 2f, bool useGamePad = false, int gamePadIndex = 1 ) : ControlComponent(controlType, speed, jumpForce, useGamePad, gamePadIndex) { private PhysicsComponent? _physicsComponent; private bool _jump; /// public override void Load() { base.Load(); _physicsComponent = Entity?.GetComponentAs(); } /// public override void Update(float delta) { base.Update(delta); if (_physicsComponent == null) return; _physicsComponent.SetLinearVelocity( ControlType == ControlType.ClassicJump ? new Vec2(0, _physicsComponent.GetLinearVelocity().Y) : Vec2.Zero ); _jump = false; var move = ControlType switch { ControlType.ClassicJump => GetJumpMovement(), _ => Vec2.Zero }; if (!move.IsZero()) { IsMoving = true; Direction = _jump ? move : move.Normalized(); } if (!IsMoving) return; var velocity = Direction * Speed; _physicsComponent.SetLinearVelocity(ControlType == ControlType.ClassicJump ? new Vec2(velocity.X, velocity.Y == 0 ? _physicsComponent.GetLinearVelocity().Y : velocity.Y) : velocity); } private Vec2 GetJumpMovement() { var result = Vec2.Zero; if (UseGamePad) result.X += InputManager.GetGamePadAxis(GamePadIndex, GamePadAxis.LeftX); else { if (InputManager.IsKeyDown(GetKey(ControlKey.Left))) result.X--; if (InputManager.IsKeyDown(GetKey(ControlKey.Right))) result.X++; } if ((!InputManager.IsKeyDown(GetKey(ControlKey.Up)) && (!UseGamePad || !InputManager.IsGamePadButtonDown(GamePadIndex, GamePadButton.A))) || !_physicsComponent!.IsOnGround()) return result; result.Y -= JumpForce; _jump = true; return result; } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Fixture/000077500000000000000000000000001512727236300235435ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Fixture/FixtureInfo.cs000066400000000000000000000020751512727236300263400ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Math; namespace SharpEngine.AetherPhysics.Fixture; /// /// Information of Fixture /// public struct FixtureInfo { /// /// Density of Fixture /// [UsedImplicitly] public float Density { get; set; } /// /// Restitution of Fixture /// [UsedImplicitly] public float Restitution { get; set; } /// /// Friction of Fixture /// [UsedImplicitly] public float Friction { get; set; } /// /// Type of Fixture /// [UsedImplicitly] public FixtureType Type { get; set; } /// /// Additional parameter of Fixture /// [UsedImplicitly] public object Parameter { get; set; } /// /// Offset of Fixture /// [UsedImplicitly] public Vec2 Offset { get; set; } /// /// Tag of Fixture /// [UsedImplicitly] public FixtureTag Tag { get; set; } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Fixture/FixtureTag.cs000066400000000000000000000004431512727236300261550ustar00rootroot00000000000000namespace SharpEngine.AetherPhysics.Fixture; /// /// Tag of Fixture /// public enum FixtureTag { /// /// Fixture will ignore collisions /// IgnoreCollisions, /// /// Normal Fixture /// Normal } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Fixture/FixtureType.cs000066400000000000000000000004211512727236300263570ustar00rootroot00000000000000namespace SharpEngine.AetherPhysics.Fixture; /// /// Type of Fixture /// public enum FixtureType { /// /// Rectangle Fixture /// Rectangle, /// /// Circle Fixture /// Circle } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Joint/000077500000000000000000000000001512727236300232005ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Joint/DistanceJoint.cs000066400000000000000000000036501512727236300262710ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Entity; using SharpEngine.Core.Math; using nkast.Aether.Physics2D.Dynamics; using DJoint = nkast.Aether.Physics2D.Dynamics.Joints.DistanceJoint; using SharpEngine.AetherPhysics.Component; namespace SharpEngine.AetherPhysics.Joint; /// /// Distance Joint /// /// Joint Target /// Joint From Position /// Joint Target Position /// Joint Length /// Joint Frequency /// Joint Damping Ratio [UsedImplicitly] public class DistanceJoint( Entity target, Vec2? fromPosition = null, Vec2? targetPosition = null, float length = -1, float frequency = -1, float dampingRatio = -1 ) : Joint(target, JointType.Distance, fromPosition ?? Vec2.Zero, targetPosition ?? Vec2.Zero) { /// /// Length of Joint /// [UsedImplicitly] public float Length { get; set; } = length; /// /// Frequency of Joint /// [UsedImplicitly] public float Frequency { get; set; } = frequency; /// /// Damping Ratio of Joint /// [UsedImplicitly] public float DampingRatio { get; set; } = dampingRatio; internal DJoint ToAetherPhysics(Body from) { var joint = new DJoint( from, Target.GetComponentAs()?.Body, FromPosition.ToAetherPhysics(), TargetPosition.ToAetherPhysics() ); if (System.Math.Abs(Length + 1) > 0.001f) joint.Length = Length; if (System.Math.Abs(Frequency + 1) > 0.001f) joint.Frequency = Frequency; if (System.Math.Abs(DampingRatio + 1) > 0.001f) joint.DampingRatio = DampingRatio; return joint; } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Joint/Joint.cs000066400000000000000000000023361512727236300246160ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Entity; using SharpEngine.Core.Math; namespace SharpEngine.AetherPhysics.Joint; /// /// Abstract class of Join /// public abstract class Joint { /// /// Target of Joint /// [UsedImplicitly] public Entity Target { get; set; } /// /// Type of Joint /// [UsedImplicitly] public JointType Type { get; set; } /// /// From position of Joint /// [UsedImplicitly] public Vec2 FromPosition { get; set; } /// /// Target Position of Joint /// [UsedImplicitly] public Vec2 TargetPosition { get; set; } /// /// Create Joint /// /// Joint Target /// Joint Type /// Joint From Position /// Joint Target Position protected Joint(Entity target, JointType type, Vec2 fromPosition, Vec2 targetPosition) { Target = target; Type = type; FromPosition = fromPosition; TargetPosition = targetPosition; } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Joint/JointType.cs000066400000000000000000000005111512727236300254510ustar00rootroot00000000000000namespace SharpEngine.AetherPhysics.Joint; /// /// Joint Type /// public enum JointType { /// /// Distance Joint /// Distance, /// /// Revolute Joint /// Revolute, /// /// Rope Joint /// Rope } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Joint/RevoluteJoint.cs000066400000000000000000000014641512727236300263450ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Entity; using SharpEngine.Core.Math; using nkast.Aether.Physics2D.Dynamics; using RJoint = nkast.Aether.Physics2D.Dynamics.Joints.RevoluteJoint; using SharpEngine.AetherPhysics.Component; namespace SharpEngine.AetherPhysics.Joint; /// /// Revolution Joint /// /// /// Create Revolution Joint /// /// Joint Target /// Joint From Position [UsedImplicitly] public class RevoluteJoint(Entity target, Vec2? fromPosition) : Joint(target, JointType.Revolute, fromPosition ?? Vec2.Zero, fromPosition ?? Vec2.Zero) { internal RJoint ToAetherPhysics(Body from) => new(from, Target.GetComponentAs()?.Body, FromPosition.ToAetherPhysics()); } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/Joint/RopeJoint.cs000066400000000000000000000024501512727236300254410ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Entity; using SharpEngine.Core.Math; using nkast.Aether.Physics2D.Dynamics; using RJoint = nkast.Aether.Physics2D.Dynamics.Joints.RopeJoint; using SharpEngine.AetherPhysics.Component; namespace SharpEngine.AetherPhysics.Joint; /// /// Rope Joint /// /// Joint Target /// Joint From Position /// Joint Target Position /// Joint Max Length [UsedImplicitly] public class RopeJoint( Entity target, Vec2? fromPosition = null, Vec2? targetPosition = null, float maxLength = -1 ) : Joint(target, JointType.Rope, fromPosition ?? Vec2.Zero, targetPosition ?? Vec2.Zero) { /// /// Max Length of Joint /// [UsedImplicitly] public float MaxLength { get; set; } = maxLength; internal RJoint ToAetherPhysics(Body from) { var joint = new RJoint( from, Target.GetComponentAs()?.Body, FromPosition.ToAetherPhysics(), TargetPosition.ToAetherPhysics() ); if (System.Math.Abs(MaxLength + 1) > 0.001f) joint.MaxLength = MaxLength; return joint; } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/PhysicsEventArgs.cs000066400000000000000000000013411512727236300257040ustar00rootroot00000000000000using JetBrains.Annotations; using SharpEngine.Core.Utils.EventArgs; using nkast.Aether.Physics2D.Dynamics.Contacts; namespace SharpEngine.AetherPhysics; /// /// Event Args for physics /// public class PhysicsEventArgs : BoolEventArgs { /// /// Sender Fixture of Event /// [UsedImplicitly] public required nkast.Aether.Physics2D.Dynamics.Fixture Sender { get; set; } /// /// Other Fixture of Event /// [UsedImplicitly] public required nkast.Aether.Physics2D.Dynamics.Fixture Other { get; set; } /// /// Contact of Event /// [UsedImplicitly] public required Contact Contact { get; set; } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/PhysicsSystem.cs000066400000000000000000000073301512727236300252760ustar00rootroot00000000000000using System.Collections.Generic; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; using nkast.Aether.Physics2D.Dynamics; using SharpEngine.Core.Entity; using System; using System.Linq; using JetBrains.Annotations; namespace SharpEngine.AetherPhysics; /// /// Scene System that adds physics World /// public class PhysicsSystem : ISceneSystem { /// /// Physic World /// public readonly World World; /// /// If Physics System is Paused /// [UsedImplicitly] public bool Paused { get; set; } private readonly Dictionary _bodies = []; private float _worldStepTimer; private const float WorldStep = 1 / 60f; private readonly List _removeBodies = []; /// /// Create a physics system /// /// Gravity (Vec2(0, 25)) public PhysicsSystem(Vec2? gravity = null) { var gravityFinal = gravity ?? new Vec2(0, 25); World = new World(gravityFinal.ToAetherPhysics()) { ContactManager = { VelocityConstraintsMultithreadThreshold = 256, PositionConstraintsMultithreadThreshold = 256, CollideMultithreadThreshold = 256 } }; } /// /// Get Entity from Body /// /// Body /// Entity /// Throw if body doesn't exist in a system [UsedImplicitly] public Entity GetEntityForBody(Body body) => _bodies.TryGetValue(body, out var entity) ? entity : throw new ArgumentException("Unknown body."); /// /// Get Body from Entity /// /// Entity /// Body [UsedImplicitly] public Body GetBodyForEntity(Entity entity) => _bodies.FirstOrDefault(x => x.Value == entity).Key; /// /// Create and add Physics Body to System /// /// Entity attached /// Position /// Rotation /// Type of Body /// Created Body public Body CreateBody(Entity entity, Vec2 position, float rotation, BodyType bodyType) { var body = World.CreateBody(position.ToAetherPhysics(), rotation, bodyType); _bodies.Add(body, entity); return body; } /// /// Remove Physics Body from System /// /// Physics Body /// If remove must be delayed (false) [UsedImplicitly] public void RemoveBody(Body body, bool delay = false) { if (delay) _removeBodies.Add(body); else { World.Remove(body); _bodies.Remove(body); } } /// public void Load() { } /// public void Unload() { } /// public void Update(float delta) { foreach (var removeBody in _removeBodies) { World.Remove(removeBody); _bodies.Remove(removeBody); } _removeBodies.Clear(); if (Paused) return; _worldStepTimer += delta; while (_worldStepTimer >= WorldStep) { World.Step(WorldStep); _worldStepTimer -= WorldStep; } World.ClearForces(); } /// public void Draw() { } /// public void OpenScene() { } /// public void CloseScene() { } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/SEAetherPhysics.cs000066400000000000000000000021411512727236300254450ustar00rootroot00000000000000using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using nkast.Aether.Physics2D.Common; namespace SharpEngine.AetherPhysics; /// /// Static class with extensions and add version functions /// // ReSharper disable once InconsistentNaming public static class SEAetherPhysics { /// /// Change SharpEngine Vec2 to Aether Physics Vector2 /// /// SharpEngine Vec2 /// Aether Physics Vector 2 public static Vector2 ToAetherPhysics(this Vec2 vec) => new(vec.X, vec.Y); /// /// Change Aether Physics Vector2 to SharpEngine Vec2 /// /// Aether Physics Vector2 /// SharpEngine Vec2 public static Vec2 ToSharpEngine(this Vector2 vec) => new(vec.X, vec.Y); /// /// Add versions to DebugManager /// public static void AddVersions() { DebugManager.Versions.Add("Aether.Physics2D", "2.2.0"); DebugManager.Versions.Add("SharpEngine.AetherPhysics", "1.6.0"); } } SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/SharpEngine.AetherPhysics.csproj000066400000000000000000000026011512727236300303130ustar00rootroot00000000000000 net10.0 true AetherPhysics Package of SharpEngine - 2D Game Engine LavaPower LavaPower Copyright (c) LavaPower 2021-2023 MIT https://github.com/SharpEngine/SharpEngine.Aether 1.6.0 true README.md true true https://github.com/SharpEngine/SharpEngine.Aether git SharpEngine,Game,Engine,AetherPhysics,Physics enable SharpEngine.Aether-1.6.0/SharpEngine.AetherPhysics/SharpEngine.AetherPhysics.csproj.user000066400000000000000000000002451512727236300312720ustar00rootroot00000000000000 SharpEngine.Aether-1.6.0/Testing/000077500000000000000000000000001512727236300165555ustar00rootroot00000000000000SharpEngine.Aether-1.6.0/Testing/MyScene.cs000066400000000000000000000026531512727236300204550ustar00rootroot00000000000000using SharpEngine.AetherPhysics; using SharpEngine.Core; using SharpEngine.Core.Component; using SharpEngine.Core.Entity; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; using nkast.Aether.Physics2D.Dynamics; using SharpEngine.AetherPhysics.Component; namespace Testing; public class MyScene : Scene { public MyScene() { AddSceneSystem(new PhysicsSystem()); var e1 = new Entity(); e1.AddComponent(new TransformComponent(new Vec2(100))); e1.AddComponent(new RectComponent(Color.Blue, new Vec2(50))); e1.AddComponent( new PhysicsComponent(fixedRotation: true, ignoreGravity: true, debugDraw: true) ) .AddCircleCollision(50, restitution: 0f); e1.AddComponent(new PhysicsControlComponent(speed: 300)); AddEntity(e1); for (var x = 0; x < 2; x++) { for (var y = 0; y < 2; y++) { var e2 = new Entity(); e2.AddComponent(new TransformComponent(new Vec2(240 + 120 * x, 80 + 120 * y), rotation: 45)); e2.AddComponent(new RectComponent(Color.Red, new Vec2(50))); e2.AddComponent(new PhysicsComponent(BodyType.Dynamic, true, false, true)) .AddRectangleCollision(new Vec2(50)); e2.AddComponent(new PhysicsAutoComponent(new Vec2(10, 10), 20)); AddEntity(e2); } } } } SharpEngine.Aether-1.6.0/Testing/Program.cs000066400000000000000000000007751512727236300205240ustar00rootroot00000000000000using SharpEngine.AetherPhysics; using SharpEngine.Core; using SharpEngine.Core.Utils; namespace Testing; internal static class Program { private static void Main() { SEAetherPhysics.AddVersions(); var window = new Window( 1280, 920, "SE Aether Physics", Color.CornflowerBlue, null, true, true, true ); window.AddScene(new MyScene()); window.Run(); } } SharpEngine.Aether-1.6.0/Testing/Testing.csproj000066400000000000000000000005561512727236300214220ustar00rootroot00000000000000 Exe net10.0 enable enable