Being.h

Go to the documentation of this file.

 
#ifndef Being_h
#define Being_h
 
#include "Directions.h"
#include "Sensing.h"

 
class Being
{
  private:
 
  public:
    boolean alive = 0; //It doesn't born yet
    uint32_t age = 0; //It just borns (0)
    SensingData sensors; //Sensing Data Struct
    byte NGS =0x00; //Neigborhood Status Map
    long ASBM = 0x00; //Active Sensor Byte Maps starts unset (32 bit total)

    void born(){
        this->alive = 1;
    }

    void dye(){
        this->alive = 0;
    }

    void activate(uint8_t idx){ //Activate a sensor
        this->ASBM |= 0x01<<idx; //Set sense bit at idx (maches with the bit in the ASBM)
    }

    void deactivate(uint8_t idx){ //Deactivate a sensor
        this->ASBM &= ~(0x01<<idx); //Unset sense bit at idx (matches with the bit in the ASBM)
    }

    boolean isactive(uint8_t bit_pos){ //Check if a sensor is active
        //Check bit on ASBM at bit_pos
        if((this->ASBM>>bit_pos) & 0x01){
            return true;//It's up
        }
        else return false;//It's down
    }

    void updateAge(){ //Update age (uptime)
        this->age = millis();
    }

    void updateNGS(Being * _ng){ //Update Neighborhood Status Map
        this->NGS = 0x00; //Reset ngstatus
        for(uint8_t i=0;i<4;i++){
            if(_ng[i].alive){
                this->NGS |= 0x01<<i; //Set sense bit at idx
            }
        }
    }

    void calcDNGS(Being * _ng){ //Infer Neighborhood Status Map
        uint8_t DNGS = 0x00; //Inferred Neighborhood Status Map
        for(uint8_t i=0;i<4;i++){
            switch (i){
                case N:
                    if(_ng[N].alive){
                        DNGS |= (_ng[N].NGS >> W & 0x01) << N_W;  //Inferring North_West neighbor
                        DNGS |= (_ng[N].NGS >> E & 0x01) << N_E;  //Inferring North_East neighbor
                    }
                    break;
                case E:
                    if(_ng[E].alive){
                        DNGS |= (_ng[E].NGS >> N & 0x01) << N_E;  //Inferring North_East neighbor
                        DNGS |= (_ng[E].NGS >> S & 0x01) << S_E;  //Inferring South_East neighbor
                    }
                    break;
                case S:
                    if(_ng[S].alive){
                        DNGS |= (_ng[S].NGS >> E & 0x01) << S_E;  //Inferring South_East neighbor
                        DNGS |= (_ng[S].NGS >> W & 0x01) << S_W;  //Inferring South_West neighbor
                    }
                    break;
                case W:
                    if(_ng[W].alive){
                        DNGS |= (_ng[W].NGS >> S & 0x01) << S_W;  //Inferring South_West neighbor
                        DNGS |= (_ng[W].NGS >> N & 0x01) << N_W;  //Inferring North_West neighbor
                    }
                    break;
                default:
                    break;
            }
        }
        this->NGS |= DNGS; //Update NGS with inferred diagonal neighbors
    }
};
 
#endif