BallisticSolutions 6.1.0

BallisticSolutions (C#)

Table of Contents

1. Installation & Dependencies
2. Example
3. Reference

Installation & Dependencies

Two packages are available depending on your project type:

Installation

Option 1: NuGet Package (Recommended)

Search for package in the NuGet manager.

Or add to your .csproj:

<ItemGroup>
  <PackageReference Include="BallisticSolutions" Version="*" />
</ItemGroup>


<ItemGroup>
  <PackageReference Include="BallisticSolutions.Godot" Version="*" />
</ItemGroup>

Option 2: DLL (Godot addon)

Add to your .csproj:

<ItemGroup>
  <Reference Include="BallisticSolutions.Godot">
    <HintPath>addons\BallisticSolutions.Godot\BallisticSolutions.Godot.dll</HintPath>
  </Reference>
  <Reference Include="MathNet.Numerics">
    <HintPath>addons\BallisticSolutions.Godot\MathNet.Numerics.dll</HintPath>
  </Reference>
</ItemGroup>

Dependencies

• MathNet.Numerics

BallisticSolutions.Godot:

• GodotSharp

Example

using Godot;
using BallisticSolutions.Godot.BsSolvers.BsVelocity;

// ...

	[Export]
	public PackedScene ProjectileScene { get; set; }

	[Export]
	public float ProjectileSpeed { get; set; } = 200;

	[Export]
	public Vector2 ProjectileAcceleration { get; set; }

	public void Shoot(Target2D target) {
		Vector2 toTarget = target.GlobalPosition - GlobalPosition;

		Vector2 velocity = BsVelocity2D.Best(
			ProjectileSpeed,
			toTarget,
			target.Velocity,
			ProjectileAcceleration,
			target.Acceleration
		);

		if (float.IsNaN(velocity.X)) {
			GD.Print("Impossible to hit the target");
			return;
		}

		var newProjectile = ProjectileScene.Instantiate<Projectile2D>();
		newProjectile.GlobalPosition = GlobalPosition;
		newProjectile.Velocity = velocity;
		newProjectile.Acceleration = ProjectileAcceleration;

		GetParent().AddChild(newProjectile);
	}

Reference

For the complete documentation, refer to the generated XML documentation.

*D suffix denotes 2D, 3D, or 4D variants — BsTime*D stands for BsTime2D, BsTime3D, and BsTime4D. Each variant uses the corresponding Vector* type (Vector2, Vector3, Vector4). All variants share the same API.

1. BsSolution<T>
2. BsSolution*D
3. BsPosition*D
4. BsTime*D
5. BsVelocity*D

BsSolution<T>

Abstract base class representing a ballistic solution. T is a floating-point numeric type (e.g., float, double).

BsSolution*D

BsSolution*D<T>? Best<T>(float projectileSpeed, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: the earliest valid solution, or null if interception is impossible.

BsSolution*D<T>? Best<T>(Vector* projectileDirection, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: the earliest valid solution, or null if interception is impossible.

BsSolution*D<T>[] All<T>(float projectileSpeed, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: all valid solutions sorted by interception time. Empty array if impossible.

BsSolution*D<T>[] All<T>(Vector* projectileDirection, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: all valid solutions sorted by interception time. Empty array if impossible.

BsPosition*D

Vector* Displacement<T>(T time, Vector* velocity, Vector* acceleration = default)

Returns: displacement under constant acceleration.

Vector* Position<T>(Vector* position, T time, Vector* velocity, Vector* acceleration = default)

Returns: position after elapsed time under constant acceleration.

Vector* Best(float projectileSpeed, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: the earliest valid impact position. Returns a NaN vector if impossible.

Vector* Best(Vector* projectileDirection, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: the earliest valid impact position. Returns a NaN vector if impossible.

Vector*[] All(float projectileSpeed, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: all valid impact positions. Empty array if impossible.

Vector*[] All(Vector* projectileDirection, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: all valid impact positions. Empty array if impossible.

BsTime*D

T Best<T>(float projectileSpeed, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: the earliest interception time (t ≥ 0). Returns NaN if impossible.

T Best<T>(Vector* projectileDirection, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: the earliest interception time (t ≥ 0). Returns NaN if impossible.

T[] All<T>(float projectileSpeed, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: all valid interception times sorted ascending. Empty array if impossible.

T[] All<T>(Vector* projectileDirection, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: all valid interception times sorted ascending. Empty array if impossible.

BsVelocity*D

Vector* Velocity<T>(T time, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: the firing velocity required to hit the target at the given time.

Vector* Best(float projectileSpeed, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: the earliest valid firing velocity. Returns a NaN vector if impossible.

Vector* Best(Vector* projectileDirection, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: the earliest valid firing velocity. Returns a NaN vector if impossible.

Vector*[] All(float projectileSpeed, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: all valid firing velocities. Empty array if impossible.

Vector*[] All(Vector* projectileDirection, Vector* toTarget, Vector* targetVelocity = default, Vector* projectileAcceleration = default, Vector* targetAcceleration = default)

Returns: all valid firing velocities. Empty array if impossible.