axiosengine/axios/Controllers/AbstractForceController.cs

323 lines
10 KiB
C#
Raw Normal View History

2012-03-19 23:57:59 +00:00
using System;
using FarseerPhysics.Dynamics;
using Microsoft.Xna.Framework;
namespace FarseerPhysics.Controllers
{
public abstract class AbstractForceController : Controller
{
#region DecayModes enum
/// <summary>
/// Modes for Decay. Actual Decay must be implemented in inheriting
/// classes
/// </summary>
public enum DecayModes
{
None,
Step,
Linear,
InverseSquare,
Curve
}
#endregion
#region ForceTypes enum
/// <summary>
/// Forcetypes are used in the decay math to properly get the distance.
/// They are also used to draw a representation in DebugView
/// </summary>
public enum ForceTypes
{
Point,
Line,
Area
}
#endregion
#region TimingModes enum
/// <summary>
/// Timing Modes
/// Switched: Standard on/off mode using the baseclass enabled property
/// Triggered: When the Trigger() method is called the force is active
/// for a specified Impulse Length
/// Curve: Still to be defined. The basic idea is having a Trigger
/// combined with a curve for the strength
/// </summary>
public enum TimingModes
{
Switched,
Triggered,
Curve
}
#endregion
/// <summary>
/// Curve to be used for Decay in Curve mode
/// </summary>
public Curve DecayCurve;
/// <summary>
/// The Forcetype of the instance
/// </summary>
public ForceTypes ForceType;
/// <summary>
/// Provided for reuse to provide Variation functionality in
/// inheriting classes
/// </summary>
protected Random Randomize;
/// <summary>
/// Curve used by Curve Mode as an animated multiplier for the force
/// strength.
/// Only positions between 0 and 1 are considered as that range is
/// stretched to have ImpulseLength.
/// </summary>
public Curve StrengthCurve;
/// <summary>
/// Constructor
/// </summary>
public AbstractForceController()
: base(ControllerType.AbstractForceController)
{
Enabled = true;
Strength = 1.0f;
Position = new Vector2(0, 0);
MaximumSpeed = 100.0f;
TimingMode = TimingModes.Switched;
ImpulseTime = 0.0f;
ImpulseLength = 1.0f;
Triggered = false;
StrengthCurve = new Curve();
Variation = 0.0f;
Randomize = new Random(1234);
DecayMode = DecayModes.None;
DecayCurve = new Curve();
DecayStart = 0.0f;
DecayEnd = 0.0f;
StrengthCurve.Keys.Add(new CurveKey(0, 5));
StrengthCurve.Keys.Add(new CurveKey(0.1f, 5));
StrengthCurve.Keys.Add(new CurveKey(0.2f, -4));
StrengthCurve.Keys.Add(new CurveKey(1f, 0));
}
/// <summary>
/// Overloaded Contstructor with supplying Timing Mode
/// </summary>
/// <param name="mode"></param>
public AbstractForceController(TimingModes mode)
: base(ControllerType.AbstractForceController)
{
TimingMode = mode;
switch (mode)
{
case TimingModes.Switched:
Enabled = true;
break;
case TimingModes.Triggered:
Enabled = false;
break;
case TimingModes.Curve:
Enabled = false;
break;
}
}
/// <summary>
/// Global Strength of the force to be applied
/// </summary>
public float Strength { get; set; }
/// <summary>
/// Position of the Force. Can be ignored (left at (0,0) for forces
/// that are not position-dependent
/// </summary>
public Vector2 Position { get; set; }
/// <summary>
/// Maximum speed of the bodies. Bodies that are travelling faster are
/// supposed to be ignored
/// </summary>
public float MaximumSpeed { get; set; }
/// <summary>
/// Maximum Force to be applied. As opposed to Maximum Speed this is
/// independent of the velocity of
/// the affected body
/// </summary>
public float MaximumForce { get; set; }
/// <summary>
/// Timing Mode of the force instance
/// </summary>
public TimingModes TimingMode { get; set; }
/// <summary>
/// Time of the current impulse. Incremented in update till
/// ImpulseLength is reached
/// </summary>
public float ImpulseTime { get; private set; }
/// <summary>
/// Length of a triggered impulse. Used in both Triggered and Curve Mode
/// </summary>
public float ImpulseLength { get; set; }
/// <summary>
/// Indicating if we are currently during an Impulse
/// (Triggered and Curve Mode)
/// </summary>
public bool Triggered { get; private set; }
/// <summary>
/// Variation of the force applied to each body affected
/// !! Must be used in inheriting classes properly !!
/// </summary>
public float Variation { get; set; }
/// <summary>
/// See DecayModes
/// </summary>
public DecayModes DecayMode { get; set; }
/// <summary>
/// Start of the distance based Decay. To set a non decaying area
/// </summary>
public float DecayStart { get; set; }
/// <summary>
/// Maximum distance a force should be applied
/// </summary>
public float DecayEnd { get; set; }
/// <summary>
/// Calculate the Decay for a given body. Meant to ease force
/// development and stick to the DRY principle and provide unified and
/// predictable decay math.
/// </summary>
/// <param name="body">The body to calculate decay for</param>
/// <returns>A multiplier to multiply the force with to add decay
/// support in inheriting classes</returns>
protected float GetDecayMultiplier(Body body)
{
//TODO: Consider ForceType in distance calculation!
float distance = (body.Position - Position).Length();
switch (DecayMode)
{
case DecayModes.None:
{
return 1.0f;
}
case DecayModes.Step:
{
if (distance < DecayEnd)
return 1.0f;
else
return 0.0f;
}
case DecayModes.Linear:
{
if (distance < DecayStart)
return 1.0f;
if (distance > DecayEnd)
return 0.0f;
return (DecayEnd - DecayStart / distance - DecayStart);
}
case DecayModes.InverseSquare:
{
if (distance < DecayStart)
return 1.0f;
else
return 1.0f / ((distance - DecayStart) * (distance - DecayStart));
}
case DecayModes.Curve:
{
if (distance < DecayStart)
return 1.0f;
else
return DecayCurve.Evaluate(distance - DecayStart);
}
default:
return 1.0f;
}
}
/// <summary>
/// Triggers the trigger modes (Trigger and Curve)
/// </summary>
public void Trigger()
{
Triggered = true;
ImpulseTime = 0;
}
/// <summary>
/// Inherited from Controller
/// Depending on the TimingMode perform timing logic and call ApplyForce()
/// </summary>
/// <param name="dt"></param>
public override void Update(float dt)
{
switch (TimingMode)
{
case TimingModes.Switched:
{
if (Enabled)
{
ApplyForce(dt, Strength);
}
break;
}
case TimingModes.Triggered:
{
if (Enabled && Triggered)
{
if (ImpulseTime < ImpulseLength)
{
ApplyForce(dt, Strength);
ImpulseTime += dt;
}
else
{
Triggered = false;
}
}
break;
}
case TimingModes.Curve:
{
if (Enabled && Triggered)
{
if (ImpulseTime < ImpulseLength)
{
ApplyForce(dt, Strength * StrengthCurve.Evaluate(ImpulseTime));
ImpulseTime += dt;
}
else
{
Triggered = false;
}
}
break;
}
}
}
/// <summary>
/// Apply the force supplying strength (wich is modified in Update()
/// according to the TimingMode
/// </summary>
/// <param name="dt"></param>
/// <param name="strength">The strength</param>
public abstract void ApplyForce(float dt, float strength);
}
}