ai.h

#pragma once
 
#include <vector>
#include <glm/glm.hpp>
 
#include "../res-management/model.h"
#include "../res-management/terrain.h"
#include "../res-management/animator.h"
#include "../utils/rigidbody.h"
 
namespace Aire {
    class Boid
    {
    private:
        glm::vec2 initialDirection = { 1.f, 0.f }; 
        glm::vec2 targetDirection; 
        Terrain* terrain; 
        void randomizePosition(Terrain* terrain, RigidbodyHandler* rigidbodyHandler) {
            float scale = terrain->getXZScale() * 0.9f;
            glm::vec2 corner_min = glm::vec2(-scale, -scale);
            float width = 2 * scale;
            bool collision = false;
            do {
                collision = false;
                float x = (float)rand() / RAND_MAX * width + corner_min.x;
                float z = (float)rand() / RAND_MAX * width + corner_min.y;
                this->currentPosition = { x, z };
            } while (collision);
        }
 
        void randomizeDirection() {
            this->currentDirection = normalize(glm::vec2{ (float)rand() / RAND_MAX, (float)rand() / RAND_MAX });
        }
 
    public:
        glm::vec2 currentDirection; 
        glm::vec2 currentPosition; 
        glm::mat4 model2world; 
        Rigidbody* rigidbody; 
        Boid(Terrain* terrain, RigidbodyHandler* rigidbodyHandler) {
            this->terrain = terrain;
            // Spawn boid at random position and direction
            randomizePosition(terrain, rigidbodyHandler);
            randomizeDirection();
            this->targetDirection = currentDirection;
            // Initial rotation for object
            float rotationAngle = acos(dot(this->initialDirection, this->currentDirection));
            // Initial translation for object
            glm::vec3 translation = glm::vec3(this->currentPosition.x,
                terrain->getHeightAt(this->currentPosition.x, this->currentPosition.y), this->currentPosition.y);
 
            this->model2world = glm::translate(glm::mat4(1.0f), translation) * glm::rotate(glm::mat4(1.0f), rotationAngle + 90, glm::vec3(0.f, 1.f, 0.f));
        };
 
        void setTargetDirection(glm::vec2 direction) {
            targetDirection = direction;
        }
 
        void updateDirection(float speed, float transition);
 
        std::vector<Boid*> findNeighbours(std::vector<Boid*> totalBoids, float radius, float visionAngle);
 
 
        glm::vec2 applyCohesion(std::vector<Boid*>neighbours, float strength) const;
 
        glm::vec2 applyAlignment(std::vector<Boid*>neighbours, float strength) const;
 
        glm::vec2 applySeparation(std::vector<Boid*> neighbours, float strength, float radius) const;
 
        glm::vec2 avoidEdges(float strength);
 
        glm::vec2 avoidObstacles(RigidbodyHandler* rigidbodyHandler, float strength);
 
        void setRigidbody(float radius, glm::vec3 pos);
    };
 
 
    class BoidManager {
    public:
        BoidManager(Model* model, Terrain* terrain, RigidbodyHandler* rigidbodyHandler) {
            this->model = model;
            model->isStatic = false;
            this->animator = nullptr;
            this->terrain = terrain;
            this->rigidbodyHandler = rigidbodyHandler;
        }
        BoidManager(Animator* animator, Terrain* terrain, RigidbodyHandler* rigidbodyHandler) {
            this->model = nullptr;
            animator->isStatic = false;
            this->animator = animator;
            this->terrain = terrain;
            this->rigidbodyHandler = rigidbodyHandler;
        }
 
        ~BoidManager() {
            for (auto boid : boids) {
                delete boid;
            }
        }
 
        Terrain* getTerrain() { return terrain; }
 
        void setTrackPlayer(bool trackPlayer) { this->trackPlayer = trackPlayer; }
 
        void addBoid();
 
        void addBoids(int numBoids);
 
        std::vector<Boid*>& getBoids() { return boids; }
 
        void setModel() { this->model = model; this->animator = nullptr; }
 
        Model* getModel() { return model; }
 
        bool hasModel() { return model != nullptr; }
 
        void setAnimator() { this->model = nullptr; this->animator = animator; }
 
        Animator* getAnimator() { return animator; }
 
        bool hasAnimator() { return animator != nullptr; }
 
        void updateBoids(float deltaTime, glm::vec3 playerPosition);
 
        void renderBoids(ShaderProgram& shader, Aire::Camera& camera);
 
    private:
        Model* model; 
        Animator* animator; 
        Terrain* terrain; 
        RigidbodyHandler* rigidbodyHandler; 
        std::vector<Boid*> boids; 
        bool trackPlayer = false; 
        float boidVisionRange = 6.f; 
        float boidVisionAngle = 150.f; 
        float cohesionStrength = 1.f; 
        float alignmentStrength = 1.f; 
        float separationStrength = 3.f; 
        float boidSpeed = 5.f; 
    };
}