Collision.h

Go to the documentation of this file.

//
// Created by iorio on 3/1/22.
//
 
#ifndef SEVN_COLLISION_H
#define SEVN_COLLISION_H
 
#include <IO.h>
#include <Processes.h>
#include <binstar.h>
#include <star.h>
 
//Forward declaration
class Star;
class Binstar;
 
 
class Kollision : public  Process{
 
public:
 
    Kollision(_UNUSED IO *_io= nullptr, bool reg = true) {
        if (reg) {
            //First register to include this Property in static array
            Register(this, &ID, name());
        }
    }
 
    static size_t ID;
    static Kollision _kollision;
    inline std::string name() override { return "Collision"; }
 
    Kollision *Instance(_UNUSED IO *_io) override;
    virtual Kollision *instance() {return nullptr;}
 
    bool is_process_ongoing() const override {return false;};
 
 
 
    static std::string log_message(_UNUSED Binstar *binstar);
 
    typedef unsigned int collision_outcome;
    static constexpr int NO_COLLISION=0;
    static constexpr int COLLISION_CE=1;
    static constexpr int COLLISION_MIX=2;
 
protected:
 
    //this a prototype for the future refactoring of the whole Process classes
    static std::map<std::string, Kollision *> & GetStaticMap(){
        static std::map<std::string, Kollision *> _locmap;
        return _locmap;
    }
    static std::vector<int> & GetUsed(){
        static std::vector<int> _used;
        return _used;
    }
    static void Register_specific(Kollision *ptr) {
        GetStaticMap().insert(std::make_pair(ptr->name(), ptr));
        GetUsed().resize(GetStaticMap().size());
        GetUsed()[GetUsed().size()-1] = 0;
    }
 
 
};
 
 
class KollisionDisabled : public Kollision{
 
public:
 
    KollisionDisabled(_UNUSED IO *_io= nullptr, bool reg = true) : Kollision(nullptr, false) {
        if(reg) {
            //Second register to handle the different options
            Register_specific(this);
        }
    }
 
    inline std::string name() override { return "disabled"; }
    static KollisionDisabled _kollisiondisabled;
    KollisionDisabled* instance() override {
        return (new KollisionDisabled(nullptr,false));
    }
    int evolve(_UNUSED Binstar *binstar) override;
};
 
class KollisionHurley : public Kollision{
 
public:
 
    KollisionHurley(_UNUSED IO *_io= nullptr, bool reg = true) : Kollision(nullptr, false) {
        if(reg) {
            //Second register to handle the different options
            Register_specific(this);
        }
    }
 
    inline std::string name() override { return "hurley"; }
    static KollisionHurley _kollisionhurley;
    KollisionHurley* instance() override {
        return (new KollisionHurley(nullptr,false));
    }
    int evolve(_UNUSED Binstar *binstar) override;
 
    static bool check_collision(Binstar *b);
    static collision_outcome outcome_collision(Binstar *b);
 
};
 
 
 
 
 
#endif //SEVN_COLLISION_H