During my work on the Boids and Flocking Project, I developed a C++ implementation of the Boids algorithm to simulate flocking behavior using Unreal Engine. Below are some of the key achievements:

• Implemented core Boids algorithm for simulating flocking behavior of birds.
• Developed advanced steering behaviors for realistic movement.
• Optimized performance for handling large numbers of Boids.
• Created visual representation using Unreal Engine.

Technologies Used

• Unreal Engine
• C++
• GitHub
• Visual Studio

Challenges and Solutions

• Challenge: Optimizing the algorithm for real-time simulation.
  Solution: Implemented spatial partitioning techniques to reduce computational complexity.
• Challenge: Creating realistic steering behaviors.
  Solution: Developed advanced steering algorithms for cohesion, separation, and alignment.

Project Achievements

• Successfully simulated flocking behavior with high performance.
• Used as a teaching tool in computer graphics and AI courses.
• Praised for clean and efficient code implementation.

Code Snippets

Below is a key code snippet demonstrating the core Boids algorithm implementation from the project:

#include "Boid.h"

// Update Boid position based on flocking behavior
void ABoid::UpdateBoid(float DeltaTime)
{
    FVector Alignment = CalculateAlignment();
    FVector Cohesion = CalculateCohesion();
    FVector Separation = CalculateSeparation();

    FVector Velocity = Alignment + Cohesion + Separation;
    Velocity = Velocity.GetClampedToMaxSize(MaxSpeed);

    FVector NewPosition = GetActorLocation() + (Velocity * DeltaTime);
    SetActorLocation(NewPosition);
}

FVector ABoid::CalculateAlignment()
{
    FVector Align = FVector::ZeroVector;
    for (ABoid* Boid : NeighboringBoids)
    {
        Align += Boid->GetVelocity();
    }
    Align /= NeighboringBoids.Num();
    Align = Align.GetClampedToMaxSize(MaxForce);
    return Align;
}

FVector ABoid::CalculateCohesion()
{
    FVector CenterOfMass = FVector::ZeroVector;
    for (ABoid* Boid : NeighboringBoids)
    {
        CenterOfMass += Boid->GetActorLocation();
    }
    CenterOfMass /= NeighboringBoids.Num();
    FVector CohesionForce = (CenterOfMass - GetActorLocation()).GetClampedToMaxSize(MaxForce);
    return CohesionForce;
}

FVector ABoid::CalculateSeparation()
{
    FVector SeparationForce = FVector::ZeroVector;
    for (ABoid* Boid : NeighboringBoids)
    {
        FVector ToBoid = GetActorLocation() - Boid->GetActorLocation();
        SeparationForce += ToBoid / ToBoid.SizeSquared();
    }
    SeparationForce = SeparationForce.GetClampedToMaxSize(MaxForce);
    return SeparationForce;
}