myEvent.h

#pragma once
 
#include "../gameplay/event.h"
#include "../gameplay/player.h"
#include "../gameplay/stateMachine.h"
 
#include "../rendering/hud.h"
 
#include "../utils/log.h"
#include "../utils/ai.h"
 
using namespace Aire;
 
//############################//
//### Events Example Start ###//
//############################//
 
// Inherit from the main Event class only
// if you want to pass additional arguments to an event.
// Declare them as class members and initialize them with desired
// values before dispatching the event.
 
struct CollisionEvent : public Event {
    float collisionDamage;
    CollisionEvent(const std::string& eventType,  float collisionDamage) : Event(eventType), collisionDamage(collisionDamage) {}
};
 
struct GameOverEvent : public Event {
    static Aire::HUD::HUD_TEXT* winText;
    static Aire::HUD::HUD_TEXT* deathText;
    static Aire::AudioSource* winSound;
    static Aire::AudioSource* deathSound;
    GameOverEvent(const std::string& eventType) : Event(eventType) {}
};
 
Aire::HUD::HUD_TEXT* GameOverEvent::winText = nullptr;
Aire::HUD::HUD_TEXT* GameOverEvent::deathText = nullptr;
Aire::AudioSource* GameOverEvent::winSound = nullptr;
Aire::AudioSource* GameOverEvent::deathSound = nullptr;
 
struct BoidEvent : public Event {
    int numBoids;
    BoidEvent(const std::string& eventType, int numBoids) : Event(eventType), numBoids(numBoids) {}
};
 
class BoidController : public Aire::GameObject {
public:
    BoidController(Aire::BoidManager* boidManager) : boidManager(boidManager) {
        Aire::EventManager::registerForEvent(this, "dispatchBoids");
    }
 
    virtual void onEvent(const Aire::Event& eventInstance) override {
        if (eventInstance.type == "dispatchBoids") {
            auto const& boidEvent = static_cast<BoidEvent const&>(eventInstance);
            if (boidManager) boidManager->addBoids(boidEvent.numBoids);
        }
    }
 
    Aire::BoidManager* boidManager;
};
 
 
// TODO maybe we'll need to handle boid<->object collision
// this would require a custom boid class to receive the event
// this does not fit very well with current implementation
 
// If you want an object to be responsive to a game event,
// it must inherit from the GameObject class and override the
// onEvent() method. Inside the method, catch the desired event
// and perform action.
//
// Make sure to register the object to the event type, otherwise
// it won't be notified when the event gets dispatched.
class MyPlayer : public Aire::Player, public Aire::GameObject {
public:
    MyPlayer(Aire::Window* window, Aire::Config* config) : Aire::Player(window, config) {
        Aire::EventManager::registerForEvent(this, "playerDied");
        Aire::EventManager::registerForEvent(this, "gameOver");
        Aire::EventManager::registerForEvent(this, "collision");
    }
 
    virtual void onEvent(const Aire::Event& eventInstance) override {
        if (eventInstance.type == "playerDied" && isAlive) {
            // If we want to access the members of a custom event, we need to cast it as follows:
            //auto const& eventCasted = static_cast<MyEvent const&>(eventInstance);
            //
            // This is required only if we need to pass additional arguments to the event.
 
            // log death
            AIRE_ERROR("Player died.");
 
            GameOverEvent::deathText->active = true;
            isAlive = false;
 
            GameOverEvent::deathSound->play();
 
            // respawn the player at the centre 
            rb->position = glm::vec3(0.f);
            //TODO handle player died event
 
        } else if (eventInstance.type == "gameOver") {
            // log game over
            AIRE_WARN("Game over.");
            if (health > 0.0) {
                // Player won
                GameOverEvent::winText->active = true;
                isAlive = false;
 
                GameOverEvent::winSound->play();
 
            } else EventManager::dispatchEvent({ "playerDied" });
        } else if (eventInstance.type == "collision") {
            // General-purpose collision event
            auto const& collision = static_cast<CollisionEvent const&>(eventInstance);
            health -= collision.collisionDamage;
            if (health<=0.0) EventManager::dispatchEvent(Event("playerDied"));
        }
    }
 
    float health = 100.0f;
    bool isAlive = true;
};
 
// This is a second example. It is there to demostrate how to do timer events.
 
struct BoidStateMachine : public StateMachine, public GameObject {
    BoidStateMachine(State* currentState) : StateMachine(currentState) {
        EventManager::registerForEvent(this, "startChasing");
        EventManager::registerForEvent(this, "stopChasing");
    }
    virtual void onEvent(const Aire::Event& eventInstance) override {
        if (eventInstance.type == "startChasing") {
            if (currentState && currentState->name == "peaceful") {
                transitionTo("chasing");
            }
        } else if (eventInstance.type == "stopChasing") {
            if (currentState && currentState->name == "chasing") {
                transitionTo("peaceful");
            }
        }
    }
};
 
struct BoidState : public State {
    Aire::BoidManager* boidMan;
 
    BoidState(const std::string& name, Aire::BoidManager* boidMan) : State{ name }, boidMan(boidMan) {}
 
    virtual void onActive() override {
        if (!boidMan) return;
        if (name == "chasing") {
            boidMan->setTrackPlayer(true);
        }
        else if (name == "peaceful") {
            boidMan->setTrackPlayer(false);
        }
    }
};
 
//############################//
//#### Events Example End ####//
//############################//