Plugin2DGrid.hpp

Go to the documentation of this file.

#ifndef PLUGIN2DGRID_HPP
#define PLUGIN2DGRID_HPP
 
#include <vector>
#include <math.h>
#include "Body2DGrid.hpp"
 
namespace Grid2D {
 
    template<typename cell_t>
    class Plugin2DGrid {
 
    private:
        double nbOccupiedPositions = 0; 
        CellGrid<cell_t> cellGrid; 
        void updateNeighbouringLocation(cell_t *c) {
 
            int x = c->getBody().get2DPosition().x();
            int y = c->getBody().get2DPosition().y();
 
            if(!cellGrid.toreX && !cellGrid.toreY){
                if ((x == 0 || x == cellGrid.width - 1) && (y == 0 || y == cellGrid.height - 1)) {
                    c->getBody().setNbNeighbouringLocations(4);
                } else if (x == 0 || x == cellGrid.width - 1 || y == 0 || y == cellGrid.height - 1) {
                    c->getBody().setNbNeighbouringLocations(6);
                } else {
                    c->getBody().setNbNeighbouringLocations(9);
                }
            }else{
                c->getBody().setNbNeighbouringLocations(9);
            }
        }
 
        void computeNeighbouringCells(cell_t * c) {
            updateNeighbouringLocation(c);
            int x = c->getBody().get2DPosition().x();
            int y = c->getBody().get2DPosition().y();
            c->clearConnectedCells();
            for (int i = -1; i <= 1; ++i) {
                for (int j = -1; j <= 1; ++j) {
                    int xi = x + i;
                    int yj = y + j;
                    if ((xi >= 0) && (xi < cellGrid.width) && (yj >= 0) && (yj < cellGrid.height)) {
                        for(auto cell : cellGrid.grid[xi][yj]){
                            if(cell != c) c->addConnectedCell(cell);
                        }
                    }else if (cellGrid.toreX && cellGrid.toreY){
                        if(xi < 0) xi = cellGrid.width -1;
                        if(xi >= cellGrid.width) xi = 0;
                        if(yj < 0) yj = cellGrid.height -1;
                        if(yj >= cellGrid.height) yj = 0;
                        for(auto cell : cellGrid.grid[xi][yj]){
                            if(cell != c) c->addConnectedCell(cell);
                        }
                    }else if(cellGrid.toreX && (yj >= 0) && (yj < cellGrid.height)){
                        if(xi < 0) xi = cellGrid.width -1;
                        if(xi >= cellGrid.width) xi = 0;
                        for(auto cell : cellGrid.grid[xi][yj]){
                            if(cell != c) c->addConnectedCell(cell);
                        }
                    }else if(cellGrid.toreY && (xi >= 0) && (xi < cellGrid.width)){
                        if(yj < 0) yj = cellGrid.height -1;
                        if(yj >= cellGrid.height) yj = 0;
                        for(auto cell : cellGrid.grid[xi][yj]){
                            if(cell != c) c->addConnectedCell(cell);
                        }
                    }
                }
            }
            c->getBody().setNbNeighbouringCells(c->getConnectedCells().size());
        }
 
    public:
        Plugin2DGrid() : cellGrid() {};
 
 
        void resizeCellGrid(int w, int h){
            cellGrid.resizeGrid(w,h);
        }
 
        void resizeCellGrid(int size){
            resizeCellGrid(size,size);
        }
 
        void setToreX(bool b){
            cellGrid.setToreX(b);
        }
 
        void setToreY(bool b){
            cellGrid.setToreY(b);
        }
 
        void setTore(bool x, bool y){  cellGrid.setTore(x,y); }
 
        inline double getNbOccupiedPositions() const{
            return nbOccupiedPositions;
        }
 
        inline double getOccupationSurfaceRatio() const{
            return ((double) nbOccupiedPositions)/(cellGrid.width * cellGrid.height);
        }
 
        template<typename world_t>
        inline double getGlobalDensity(world_t *w) const{
            return (double) w->cells.size()/(cellGrid.width * cellGrid.height);
        }
 
        inline CellGrid<cell_t> *getCellGrid() { return &cellGrid; }
 
        template<typename world_t>
        void onAddCell(world_t *w) {
           for (cell_t *c : w->newCells) {
                int x = c->getBody().get2DPosition().x();
                int y = c->getBody().get2DPosition().y();
                cellGrid.grid[x][y].push_back(c);
            }
        }
 
        template<typename world_t>
        void preBehaviorUpdate(world_t *w){
            //updatePositions();
            for (cell_t *c : w->cells) {
                computeNeighbouringCells(c);
            }
        }
 
        template<typename world_t>
        void preDeleteDeadCellsUpdate(world_t *w) {
            for (cell_t *c : w->cells) {
                if (c->isDead()) {
                    int x = c->getBody().get2DPosition().x();
                    int y = c->getBody().get2DPosition().y();
                    for (int i = 0; i < cellGrid.grid[x][y].size(); ++i) {
                        if (cellGrid.grid[x][y][i] == c) {
                            cellGrid.grid[x][y].erase(cellGrid.grid[x][y].begin() + i);
                        }
                    }
                }
            }
        }
    };
}
#endif