NSteer 2: Laying down some interfaces

In the previous episode, we laid down the concepts and “lexical” language about autonomous agents. We can start to design interfaces for each concept identified previously.  Here’s a concept summary to get started:

Concept summary

• Dynamic concepts
  • Agent, the canonical autonomous agent,
  • Behavior, the canonical behavior,
  • Body, an instance defining the kinetic dynamics of the agent,
  • Vision, what the agent sees,
  • Integrators integrate the motion dynamics,
  • Saturators, saturate scalars and vectors,
• Visualization concepts
  • Visualizable: can be visible/hidden, can be rendered,
  • Sprite: a graphical element with a background and a border
  • Artifact, a dynamic or visual artifact that can be attached to an agent (e.g. smoke trail, hallow, etc…). An artifact is owned by agent.
  • A scene is the graphical layer abstraction.
  • A world provides dimensions and projection methods,
• Service concepts
  • Agent service, maintains a list of active actions,
  • World service, accesses world instance
  • Integrator service, manages agent movement integration and force resolution,
  • Behavior service, manages local and global behaviors,
  • …

On top of those concepts, remember that we are going to work with the System.Components model-container-services interfaces: IComponent, IContainer.

Dynamic concepts

An agent has a body, a behavior, a vision and can be visualized.

public interface IAgent : IComponent, IVisualizable
{
    IBody Body { get;}
    IBehavior Behavior { get;}
    IVision Vision { get;}
}

A behavior computes the steering force and is also considered as an artifact.

public interface IBehavior : IArtifact
{
    PointF ComputeSteering();
}

A body implements the kinetics of the agent and is as well an artifact.

public interface IBody : IArtifact
{
    float Mass { get;}

    PointF Position { get;}
    float Direction { get;}
    Referential Anchor { get;}

    PointF Velocity { get;}
    PointF Acceleration { get;}

    IPointSaturator VelocitySaturator { get; set;}
    IPointSaturator AccelerationSaturator { get; set;}

    void Update(
        PointF acceleration, 
        PointF velocity, 
        PointF position);
}

There are some comments to do about this interface.
1. IPointSaturator is the interface defining PointF saturator. In fact, it is very important to make sure that the agents have a maximum speed!
2. Referential is the local referential attached to the agent.
3. There is one major lack in this interface, the inertia, the rotation velocity and acceleration. For the sake of simplicity, I decided to leave those aside for now.

A vision determines if an agent can see another, it has a maximum range (and is an artifact)

public interface IVision : IArtifact
{
    float MaxRange { get;}
    bool CanSee(IAgent agent);
}

An integrator integrates the motion dynamics,

public interface IIntegrator
{
    void Integrate(IBody body, PointF steering);
}

A saturator will rescale a vector or a scalar depending on the body state.

It also provides a way to determine the maximum vector norm (norm-2) depending on the “attack” angle.

public interface IScalarSaturator
{
    float Saturate(IBody body, float value);
} 
public interface IPointSaturator
{
    PointF Saturate(IBody body, PointF vector);
    float GetMaxNormFromAngle(float value);
}

Visualization concepts

A scene provides the methods to render lines, circles, etc…

public interface IScene : IComponent
{
    void Prepare();
    void Flush();

    void DrawLine(Pen pen, PointF start, PointF end);
    ...   

    void PushTranslateTransform(float dx, float dy);
    ...
    void PopTransform();
}

A visualizable element can be visible/hidden and rendered,

public interface IVisualizable
{
    bool Visible { get;set;}
    void Render(IScene scene);
}

A sprite is a graphical element with a background and a border

public interface ISprite : IVisualizable, IDisposable
{
    string Name { get;}
    Font Font { get;set;}
    Color BackgroundColor { get;set;}
    Color StrokeColor { get;set;}
    float StrokeWidth { get;set;}
}

I’ve added the name for debugging reasons.

An artifact is a sprite attached to an agent (e.g. smoke trail, hallow, etc…).

public interface IArtifact : ISprite, IOwned<IAgent>
{}
public interface IOwned<T>
{
    event EventHandler OwnerChanged;
    T Owner { get;set;}
}

The world contains world dimensions and projection from/to screen.

public interface IWorld
{
    Size WorldSize { get;}
    Size ScreenSize { get;}
    PointF ScreenToWorld(PointF point);
    PointF WorldToScreen(PointF point);
    PointF ToWorldRatio{get;}
    PointF ToScreenRatio {get;}
}

Service concepts

I’ll skip the service concepts for now. They basically provide access to the different instances of neighborhood, obstacle manager, agent list, etc... For now, it’s to time have a break and a well-deserved cool beer.