bubble_field.h

Go to the documentation of this file.

#ifndef _BUBBLE_FIELD_H_
#define _BUBBLE_FIELD_H_

#include <cmath>
#include <list>
#include <vector>

#include "bubble.h"
#include "bubble_generator.h"
#include "time_updateable.h"
#include "templates/callable_back.h"

class BubbleField: public TimeUpdateable, public GraphicalNode,
        public Templates::CallableBack<Bubble>
{
        private:

                class Coordinates
                {
                        public:

                                unsigned plate;
                                unsigned x;
                                unsigned y;

                        public:

                                Coordinates(unsigned _plate, unsigned _x, unsigned _y):
                                        plate(_plate), x(_x), y(_y)
                                {
                                }

                                bool operator < (const Coordinates& rhs) const
                                {
                                        if (plate == rhs.plate) {
                                                if (x == rhs.x) {
                                                        return y < rhs.y;
                                                } else {
                                                        return x < rhs.x;
                                                }
                                        } else {
                                                return plate < rhs.plate;
                                        }
                                }

                                bool operator ==  (const Coordinates& rhs) const
                                {
                                        return plate == rhs.plate && x == rhs.x && y == rhs.y;
                                }

                                bool operator !=  (const Coordinates& rhs) const
                                {
                                        return !(*this == rhs);
                                }
                };

                class isInvalidPosition
                {
                        private:

                                const BubbleField& _bubbleField;

                        public:

                                isInvalidPosition(const BubbleField& bubbleField):
                                        _bubbleField(bubbleField)
                                {
                                }

                                bool operator() (const Coordinates& coords)
                                {
                                        return !_bubbleField.isValidPosition(coords.plate, coords.x, coords.y);
                                }

                };

                class FallingBubblesStorage: public TimeUpdateable, public GraphicalNode
                {
                        private:

                                typedef std::list<Bubble *> StorageType;

                                StorageType _storage;

                        public:

                                FallingBubblesStorage();

                                ~FallingBubblesStorage();

                                // Overrides
                                virtual void timeUpdate(float dt);

                                void addBubble(Bubble* bubble);

                };

        private:

                static const unsigned BUBBLES_IN_ROW;

                typedef Bubble*** BubblePlate;
                typedef std::vector<BubblePlate> FieldContent;

                FieldContent _content;

                Templates::CallableBack<BubbleField>* _addBubbleDone;

                std::list<Bubble *> _explodingBubbles;

                int _explodingBubblesCount;

                FallingBubblesStorage _fallingBubbles;

                void (*_successGameEndFunc)();

        private:

                // Disable copy constructor and assignment operator
                BubbleField(const BubbleField &);
                BubbleField & operator=(const BubbleField &);

                unsigned bubblesInPlateRow(unsigned index) const;

                bool isValidPosition(unsigned plate, unsigned x, unsigned y) const;

                static bool isInCollisionWithWall(const SbVec3f& position);

                bool bubbleCollidesInPlate(unsigned plate, const SbVec3f& position) const;

                void addCollidingBubblesInPlateToVector(unsigned plate, const Bubble* bubble,
                                std::vector<const Bubble*>& collidingBubbles) const;

                void solveCollisionWithWall(Bubble* bubble);

                void solveCollisionWithBubble(Bubble* bubble);

                void destroyBubblesInCluster(const Coordinates& position);

                void removeBubblesNotConnectedWithWall();

                Coordinates searchForPosition(Bubble* bubble) const;

                std::vector<const Bubble*> getCollidingBubbles(Bubble* bubble) const;

                std::list<Coordinates> getNeighboursCoords(const Coordinates& coords) const;

                void addBubble(Bubble* bubble, unsigned plate, unsigned x, unsigned y);

                void addNeighboursTowardsWall(const BubbleGenerator* bubbleGen,
                        const Coordinates& coords);

                bool isConnectedWithWall(const Coordinates& coords,
                                std::vector<Coordinates> processedCoords,
                                Coordinates& nearestToWallCoords) const;

                bool isConnectedWithWall(const Coordinates& coords) const;

                static unsigned oiXYCoordinateToLocal(float oiCoord, unsigned plate,
                                float (*roundFunc)(float) = roundf);

                static unsigned oiZCoordinateToLocal(float oiCoord, float (*roundFunc)(float) = roundf);

                static SbVec3f localCoordinatesToOI(unsigned plate, unsigned x, unsigned y);

                static SbVec3f localCoordinatesToOI(Coordinates local);

        public:

                BubbleField();

                ~BubbleField();

                void setOnSuccessfullGameEndCallback(void (*callback)());

                void generateStartingLayout(const BubbleGenerator* bubbleGen,
                        unsigned numOfInitiallyFilledPlates, float probCellContainBubble);

                void addBubble(Bubble* bubble, Templates::CallableBack<BubbleField>* addBubbleDone);

                bool isInCollision(const SbVec3f& position);

                static unsigned getNumberOfBubblesInRow() { return BUBBLES_IN_ROW; }

                // Override
                virtual void timeUpdate(float dt);

                // Override
                virtual void callableBackNotify(Bubble *subject);
};

#endif