pax_global_header00006660000000000000000000000064145416011600014510gustar00rootroot0000000000000052 comment=fbcb6a391facf73a3ad1dd432647e58a89d70594 SharpEngine.Aether-1.2.2/000077500000000000000000000000001454160116000151245ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/.github/000077500000000000000000000000001454160116000164645ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/.github/workflows/000077500000000000000000000000001454160116000205215ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/.github/workflows/build.yml000066400000000000000000000023271454160116000223470ustar00rootroot00000000000000name: 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.2.2/.github/workflows/dotnet.yml000066400000000000000000000050051454160116000225410ustar00rootroot00000000000000# 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@v3 with: fetch-depth: 0 - name: Setup .NET uses: actions/setup-dotnet@v3 - name: Restore run: dotnet restore - name: Build run: dotnet build SharpEngine.AetherPhysics/SharpEngine.AetherPhysics.csproj -c Release - name: Pack Nuget run: dotnet pack SharpEngine.AetherPhysics/SharpEngine.AetherPhysics.csproj -c Release --no-build --output ${{ env.NuGetDirectory }} - uses: actions/upload-artifact@v3 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@v3 - uses: actions/download-artifact@v3 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@v3 - name: Setup .NET uses: actions/setup-dotnet@v3 - name: Run tests run: dotnet test --configuration Release deploy: runs-on: ubuntu-latest needs: [ validate_nuget, run_test ] steps: - uses: actions/download-artifact@v3 with: name: nuget path: ${{ env.NuGetDirectory }} - name: Setup .NET uses: actions/setup-dotnet@v3 - 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.2.2/.gitignore000066400000000000000000000000751454160116000171160ustar00rootroot00000000000000bin/ obj/ /packages/ riderModule.iml /_ReSharper.Caches/ .vs/SharpEngine.Aether-1.2.2/.idea/000077500000000000000000000000001454160116000161045ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/.idea/.idea.SharpEngine.Aether/000077500000000000000000000000001454160116000224755ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/.idea/.idea.SharpEngine.Aether/.idea/000077500000000000000000000000001454160116000234555ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/.idea/.idea.SharpEngine.Aether/.idea/.gitignore000066400000000000000000000004371454160116000254510ustar00rootroot00000000000000# 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.2.2/.idea/.idea.SharpEngine.Aether/.idea/indexLayout.xml000066400000000000000000000003061454160116000265030ustar00rootroot00000000000000 SharpEngine.Aether-1.2.2/.idea/.idea.SharpEngine.Aether/.idea/misc.xml000066400000000000000000000003241454160116000251310ustar00rootroot00000000000000 SharpEngine.Aether-1.2.2/.idea/.idea.SharpEngine.Aether/.idea/vcs.xml000066400000000000000000000002471454160116000247750ustar00rootroot00000000000000 SharpEngine.Aether-1.2.2/CHANGELOG.md000066400000000000000000000014411454160116000167350ustar00rootroot00000000000000# Changelog ### Légende [+] Add
[\~] Modification
[-] Suppression
[#] Bug Fixes
[.] Others ### V 1.2.2 - 23/12/2023 [\~] PhysicsComponent : AddRectangleCollision and AddCircleCollision return component
[#] PhysicsComponent : GetPosition returns 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.2.2/CONTRIBUTING.md000066400000000000000000000017661454160116000173670ustar00rootroot00000000000000# 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.2.2/README.md000066400000000000000000000002661454160116000164070ustar00rootroot00000000000000# SharpEngine.Aether Aether Package of SharpEngine - C# 2D Game Engine ## Installation, Download, Usage *Coming Soon* ## Dependencies - Net8 - SharpEngine.Core - Aether Physics SharpEngine.Aether-1.2.2/SharpEngine.Aether.sln000066400000000000000000000024231454160116000212550ustar00rootroot00000000000000 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.2.2/SharpEngine.AetherPhysics/000077500000000000000000000000001454160116000221015ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/Fixture/000077500000000000000000000000001454160116000235275ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/Fixture/FixtureInfo.cs000066400000000000000000000016161454160116000263240ustar00rootroot00000000000000using SharpEngine.Core.Math; namespace SharpEngine.AetherPhysics.Fixture; /// /// Informations of Fixture /// public struct FixtureInfo { /// /// Density of Fixture /// public float Density { get; set; } /// /// Restitution of Fixture /// public float Restitution { get; set; } /// /// Friction of Fixture /// public float Friction { get; set; } /// /// Type of Fixture /// public FixtureType Type { get; set; } /// /// Additional parameter of Fixture /// public object Parameter { get; set; } /// /// Offset of Fixture /// public Vec2 Offset { get; set; } /// /// Tag of Fixture /// public FixtureTag Tag { get; set; } } SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/Fixture/FixtureTag.cs000066400000000000000000000004431454160116000261410ustar00rootroot00000000000000namespace SharpEngine.AetherPhysics.Fixture; /// /// Tag of Fixture /// public enum FixtureTag { /// /// Fixture will ignore collisions /// IgnoreCollisions, /// /// Normal Fixture /// Normal } SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/Fixture/FixtureType.cs000066400000000000000000000004211454160116000263430ustar00rootroot00000000000000namespace SharpEngine.AetherPhysics.Fixture; /// /// Type of Fixture /// public enum FixtureType { /// /// Rectangle Fixture /// Rectangle, /// /// Circle Fixture /// Circle } SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/Joint/000077500000000000000000000000001454160116000231645ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/Joint/DistanceJoint.cs000066400000000000000000000034201454160116000262500ustar00rootroot00000000000000using SharpEngine.Core.Entity; using SharpEngine.Core.Math; using nkast.Aether.Physics2D.Dynamics; using DJoint = nkast.Aether.Physics2D.Dynamics.Joints.DistanceJoint; namespace SharpEngine.AetherPhysics.Joint; /// /// Distance Joint /// /// Joint Target /// Joint From Position /// Joint Target Position /// Joint Length /// Joint Frequency /// Joint Damping Ratio 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 /// public float Length { get; set; } = length; /// /// Frequency of Joint /// public float Frequency { get; set; } = frequency; /// /// Damping Ratio of Joint /// 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.2.2/SharpEngine.AetherPhysics/Joint/Joint.cs000066400000000000000000000021551454160116000246010ustar00rootroot00000000000000using SharpEngine.Core.Entity; using SharpEngine.Core.Math; namespace SharpEngine.AetherPhysics.Joint; /// /// Abstract class of Join /// public abstract class Joint { /// /// Target of Joint /// public Entity Target { get; set; } /// /// Type of Joint /// public JointType Type { get; set; } /// /// From position of Joint /// public Vec2 FromPosition { get; set; } /// /// Target Position of Joint /// 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.2.2/SharpEngine.AetherPhysics/Joint/JointType.cs000066400000000000000000000005111454160116000254350ustar00rootroot00000000000000namespace SharpEngine.AetherPhysics.Joint; /// /// Joint Type /// public enum JointType { /// /// Distance Joint /// Distance, /// /// Revolute Joint /// Revolute, /// /// Rope Joint /// Rope } SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/Joint/RevoluteJoint.cs000066400000000000000000000013331454160116000263240ustar00rootroot00000000000000using SharpEngine.Core.Entity; using SharpEngine.Core.Math; using nkast.Aether.Physics2D.Dynamics; using RJoint = nkast.Aether.Physics2D.Dynamics.Joints.RevoluteJoint; namespace SharpEngine.AetherPhysics.Joint; /// /// Revolution Joint /// /// /// Create Revolution Joint /// /// Joint Target /// Joint From Position 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.2.2/SharpEngine.AetherPhysics/Joint/RopeJoint.cs000066400000000000000000000022721454160116000254270ustar00rootroot00000000000000using SharpEngine.Core.Entity; using SharpEngine.Core.Math; using nkast.Aether.Physics2D.Dynamics; using RJoint = nkast.Aether.Physics2D.Dynamics.Joints.RopeJoint; namespace SharpEngine.AetherPhysics.Joint; /// /// Rope Joint /// /// Joint Target /// Joint From Position /// Joint Target Position /// Joint Max Length 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 /// 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.2.2/SharpEngine.AetherPhysics/PhysicsComponent.cs000066400000000000000000000304431454160116000257410ustar00rootroot00000000000000using System; using System.Collections.Generic; using System.Diagnostics; 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; namespace SharpEngine.AetherPhysics; /// /// Components which add physics /// /// /// Create PhysicsComponent /// /// Type of Body /// Ignore Gravity /// Rotation fixed /// Debug Draw public class PhysicsComponent( BodyType bodyType = BodyType.Dynamic, bool ignoreGravity = false, bool fixedRotation = false, bool debugDraw = false ) : Component { /// /// Body Physics /// public Body? Body { get; set; } /// /// Draw debug information /// public bool DebugDraw { get; set; } = debugDraw; /// /// Event which be called when collision /// public EventHandler? CollisionCallback { get; set; } /// /// Event which be called when separation /// public EventHandler? SeparationCallback { get; set; } private readonly BodyType _bodyType = bodyType; private readonly List _fixtures = []; private readonly List _joints = []; private readonly bool _fixedRotation = fixedRotation; private readonly bool _ignoreGravity = ignoreGravity; private readonly List> _debugDrawings = []; private readonly List _contacts = []; private TransformComponent? _transform; /// /// Return Position of Body /// /// Body Position public Vec2 GetPosition() => new(Body!.Position.X * 50, Body.Position.Y * 50); /// /// Define Position of Body /// /// Body Position 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 public void ApplyLinearImpulse(Vec2 impulse) => Body!.ApplyLinearImpulse((impulse * 0.02f).ToAetherPhysics()); /// /// Return Rotation of Body /// /// Body Rotation public int GetRotation() => (int)(Body!.Rotation * 180 / MathHelper.Pi); /// /// Define Rotation of Body /// /// Body Rotation public void SetRotation(int rotation) => Body!.Rotation = rotation * MathHelper.Pi / 180f; /// /// Add Rectangle Collision /// /// Collision Size /// Collision Offset /// Collision Density /// Collision Restitution /// Collision Friction /// Collision Tag public PhysicsComponent AddRectangleCollision( Vec2 size, Vec2? offset = null, float density = 1f, float restitution = 0.5f, float friction = 0.5f, FixtureTag tag = FixtureTag.Normal ) { var fixture = new FixtureInfo { Density = density, Restitution = restitution, Friction = friction, Type = FixtureType.Rectangle, Parameter = size * 0.02f, Offset = offset * 0.02f ?? Vec2.Zero, Tag = tag }; _debugDrawings.Add(["rectangle", size, offset ?? Vec2.Zero]); _fixtures.Add(fixture); return this; } /// /// Add Circle Collision /// /// Collision Radius /// Collision Offset /// Collision Density /// Collision Restitution /// Collision Friction /// Collision Tag public PhysicsComponent AddCircleCollision( float radius, Vec2? offset = null, float density = 1f, float restitution = 0.5f, float friction = 0.5f, FixtureTag tag = FixtureTag.Normal ) { var fixture = new FixtureInfo { Density = density, Restitution = restitution, Friction = friction, Type = FixtureType.Circle, Parameter = radius * 0.02f, Offset = offset * 0.02f ?? Vec2.Zero, Tag = tag }; _debugDrawings.Add(["circle", radius, offset ?? Vec2.Zero]); _fixtures.Add(fixture); return this; } /// /// Return if entity is on ground /// /// If is on 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 public void AddJoint(Joint.Joint joint) => _joints.Add(joint); /// /// Remove Body /// 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?; Debug.Assert(size != null, nameof(size) + " != null"); fixture = Body.CreateRectangle( size.Value.X, size.Value.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.Position = (Body.Position * 50f).ToSharpEngine(); _transform.Rotation = (int)MathHelper.ToDegrees(Body.Rotation); } /// public override void Draw() { base.Draw(); if (_transform == null) return; if (DebugDraw) { 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.2.2/SharpEngine.AetherPhysics/PhysicsControlComponent.cs000066400000000000000000000055161454160116000273050ustar00rootroot00000000000000using SharpEngine.AetherPhysics; using SharpEngine.Core.Component; using SharpEngine.Core.Input; using SharpEngine.Core.Manager; using SharpEngine.Core.Math; namespace SharpEngine.AetherPhysics; /// /// Physics version of ControlComponent /// /// Create Physics Control Component /// Control Type (FourDirection) /// Speed (300) /// Jump Force (3) /// Use Game Pad (false) /// Game Pad Index (1) 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; if(ControlType == ControlType.ClassicJump) _physicsComponent.SetLinearVelocity(new Vec2(velocity.X, velocity.Y == 0 ? _physicsComponent.GetLinearVelocity().Y : velocity.Y)); else _physicsComponent.SetLinearVelocity(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.IsKeyPressed(GetKey(ControlKey.Up)) || ( UseGamePad && InputManager.IsGamePadButtonPressed(GamePadIndex, GamePadButton.A))) && _physicsComponent!.IsOnGround() ) { result.Y -= JumpForce; _jump = true; } return result; } } SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/PhysicsEventArgs.cs000066400000000000000000000012051454160116000256670ustar00rootroot00000000000000using 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 /// public required nkast.Aether.Physics2D.Dynamics.Fixture Sender { get; set; } /// /// Other Fixture of Event /// public required nkast.Aether.Physics2D.Dynamics.Fixture Other { get; set; } /// /// Contact of Event /// public required Contact Contact { get; set; } } SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/PhysicsSystem.cs000066400000000000000000000066501454160116000252660ustar00rootroot00000000000000using System.Collections.Generic; using SharpEngine.Core.Math; using SharpEngine.Core.Utils; using nkast.Aether.Physics2D.Dynamics; using SharpEngine.Core.Entity; using System; namespace SharpEngine.AetherPhysics; /// /// Scene System which add physics World /// public class PhysicsSystem : ISceneSystem { /// /// Physic World /// public readonly World World; /// /// If Physics System is Paused /// public bool Paused { get; set; } private readonly Dictionary _bodies = []; private float _worldStepTimer; private const float WorldStep = 1 / 60f; private readonly List _removeBodies = []; /// /// Create 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 system public Entity GetEntityForBody(Body body) { if(_bodies.TryGetValue(body, out var entity)) return entity; throw new ArgumentException("Unknown body."); } /// /// 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) 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) { _worldStepTimer += delta; while (_worldStepTimer >= WorldStep) { World.Step(WorldStep); _worldStepTimer -= WorldStep; } World.ClearForces(); } } /// public void Draw() { } /// public void OpenScene() { } /// public void CloseScene() { } } SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/SEAetherPhysics.cs000066400000000000000000000020641454160116000254350ustar00rootroot00000000000000using SharpEngine.Core.Manager; using SharpEngine.Core.Math; using nkast.Aether.Physics2D.Common; namespace SharpEngine.AetherPhysics; /// /// Static class with extensions and add version functions /// 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.0.0"); DebugManager.Versions.Add("SharpEngine.AetherPhysics", "1.2.2"); } } SharpEngine.Aether-1.2.2/SharpEngine.AetherPhysics/SharpEngine.AetherPhysics.csproj000066400000000000000000000026001454160116000302760ustar00rootroot00000000000000 net8.0 true AetherPhysics Package of SharpEngine - 2D Game Engine LavaPower LavaPower Copyright (c) LavaPower 2021-2023 MIT https://github.com/SharpEngine/SharpEngine.Aether 1.2.2 true README.md true true https://github.com/SharpEngine/SharpEngine.Aether git SharpEngine,Game,Engine,AetherPhysics,Physics enable SharpEngine.Aether-1.2.2/Testing/000077500000000000000000000000001454160116000165415ustar00rootroot00000000000000SharpEngine.Aether-1.2.2/Testing/MyScene.cs000066400000000000000000000024601454160116000204350ustar00rootroot00000000000000using 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; 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))); e2.AddComponent(new RectComponent(Color.Red, new Vec2(50))); e2.AddComponent(new PhysicsComponent(BodyType.Static, true, true, true)) .AddRectangleCollision(new Vec2(50), restitution: 0f); AddEntity(e2); } } } } SharpEngine.Aether-1.2.2/Testing/Program.cs000066400000000000000000000011541454160116000205000ustar00rootroot00000000000000using SharpEngine.AetherPhysics; using SharpEngine.Core; using SharpEngine.Core.Manager; 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 ) { RenderImGui = DebugManager.CreateSeImGuiWindow }; window.AddScene(new MyScene()); window.Run(); } } SharpEngine.Aether-1.2.2/Testing/Testing.csproj000066400000000000000000000005551454160116000214050ustar00rootroot00000000000000 Exe net8.0 enable enable