H073.StateKit 1.0.0

StateKit

StateKit is a robust state management library designed to handle state transitions efficiently in any application. It offers two distinct approaches for state management:

1. State Management with Context (StateCTracker<T>): Designed for scenarios where states need to share and modify common data (Context).
2. Simple State Management (StateTracker): Ideal for lightweight state machines where no shared data (Context) is required.

Features

• Versatile State Management:
  • Use StateCTracker<T> for shared context.
  • Use StateTracker for simple state handling.
• Modular State Logic:
  • Encapsulate logic in StateBase or StateCBase<T> classes.
• Seamless Transitions:
  • Transition between states easily with CheckTransitions.
• Lightweight and Flexible:
  • Handle both reference and value types (StateCTracker<T>).

Installation

You can install the package via NuGet:

dotnet add package StateKit

Why Two Types of State Management?

1. State Management with Context

• States share a common context (T), which allows them to read and modify shared data.
• Advantages:
  • Useful for managing complex systems where states depend on shared information.
  • Reduces external dependencies by keeping shared data within the state machine.
• Example Use Case:
  • A game where a player’s health, position, or inventory is shared across multiple states.

2. Simple State Management

• States are independent and do not require shared data.
• Advantages:
  • Lightweight and straightforward.
  • Suitable for simpler applications or systems with isolated states.
• Example Use Case:
  • A traffic light system with states like Red, Yellow, and Green.

Usage

1. State Management with Context (StateCTracker<T>)

Define Contextual States

using StateKit;

public class Player
{
    public int Health { get; set; }
    public bool IsMoving { get; set; }
}

public class IdleState : StateCBase<Player>
{
    public override void Enter()
    {
        Console.WriteLine("Player is now idle.");
    }

    public override void Update(float delta)
    {
        Console.WriteLine("Player stands does nothing");
    }

    public override StateCBase<Player>? CheckTransitions()
    {
        if (Context.IsMoving)
        {
            return new WalkingState();
        }
        return null;
    }
}

public class WalkingState : StateCBase<Player>
{
    public override void Enter()
    {
        Console.WriteLine("Player started walking.");
    }

    public override void Update(float delta)
    {
        Console.WriteLine("Player is walking...");
    }

    public override StateCBase<Player>? CheckTransitions()
    {
        if (!Context.IsMoving)
        {
            return new IdleState();
        }
        return null;
    }
}

Initialize and Use StateCTracker<T>

Player player = new Player { Health = 100, IsMoving = false };
StateCTracker<Player> tracker = new StateCTracker<Player>(player);

tracker.SetState(new IdleState());

while (true)
{
    tracker.Update(0.016f); // Simulate update loop at 60 FPS
}

2. Simple State Management (StateTracker)

Define Simple States

using StateKit;

public class RedLightState : StateBase
{
    public override void Enter()
    {
        Console.WriteLine("Red Light: Stop.");
    }

    public override StateBase? CheckTransitions()
    {
        return new GreenLightState();
    }
}

public class GreenLightState : StateBase
{
    public override void Enter()
    {
        Console.WriteLine("Green Light: Go.");
    }

    public override StateBase? CheckTransitions()
    {
        return new RedLightState();
    }
}

Initialize and Use StateTracker

StateTracker tracker = new StateTracker();

tracker.SetState(new RedLightState());

while (true)
{
    tracker.Update(1.0f); // Simulate a 1-second interval
}

Comparison Table

License

This project is licensed under the MIT License.