neofx-zoomedit/Room.h

#ifndef ROOM_H_
#define ROOM_H_

#include "Polygon.h"
#include "SharedPtr.h"
#include "LevelObject.h"
#include "VertexProvider.h"
#include "EdgeProvider.h"
#include <string>


class Room : public LevelObject, private VertexProvider, private EdgeProvider {
  private:
    class RoomVertex {
      public:
        virtual const Vertex& operator*() const = 0;
        const Vertex* operator->() {return &**this;}
                
        virtual ~RoomVertex() {}
        
        virtual const Vertex& operator+=(const Vertex &v) {return **this;}
        virtual const Vertex& operator-=(const Vertex &v) {return **this;}
        
        virtual void setLocation(float x, float y) {}
        
        virtual bool isDirect() const = 0;
    };
    
    class RoomVertexDirect : public RoomVertex {
      private:
        Vertex vertex;
        
      public:
        RoomVertexDirect(const Vertex &v) : vertex(v) {}
        
        virtual const Vertex& operator*() const {
          return vertex;
        }
        
        virtual const Vertex& operator+=(const Vertex &v) {
          vertex += v;
          return vertex;
        }
        
        virtual const Vertex& operator-=(const Vertex &v) {
          vertex -= v;
          return vertex;
        }
        
        virtual void setLocation(float x, float y) {
          vertex.setLocation(x, y);
        }
        
        virtual bool isDirect() const {return true;}
    };
    
    class RoomVertexIndirect : public RoomVertex {
      private:
        LevelVertex vertex;
        
      public:
        RoomVertexIndirect(const LevelVertex &v) : vertex(v) {}
        
        virtual const Vertex& operator*() const {
          return *vertex;
        }
        
        virtual bool isDirect() const {return false;}
    };
    
    
    std::string name;
    float height;
    
    std::vector<SharedPtr<RoomVertex> > vertices;
    std::vector<Edge> edges;
    
    void addEdge() {
      if(vertices.size() < 2)
        return;
      
      if(vertices.size() == 2) {
        edges.push_back(Edge(LevelVertex(this, 0, this), LevelVertex(this, 1, this)));
        return;
      }
      
      edges.push_back(Edge(LevelVertex(this, vertices.size()-2, this), LevelVertex(this, vertices.size()-1, this)));
    }
    
  public:
    Room() {height = 10;}
    Room(std::string name) {this->name = name; height = 10;}
    
    Room(const Room &room) : name(room.name), height(room.height), vertices(room.vertices) {
      for(std::vector<Edge>::const_iterator edge = room.edges.begin(); edge != room.edges.end(); edge++) {
        LevelVertex v1(this, edge->getVertex1().getId(), this);
        LevelVertex v2(this, edge->getVertex2().getId(), this);
        edges.push_back(Edge(v1, v2));
      }
    }
    
    const Room& operator=(const Room &room);
    
    std::string &getName() {return name;}
    const std::string &getName() const {return name;}
    void setName(const std::string &name) {this->name = name;}
    
    float getHeight() const {return height;}
    void setHeight(float height) {this->height = height;}
    
    void addVertex(Vertex v) {
      vertices.push_back(SharedPtr<RoomVertex>(new RoomVertexDirect(v)));
      addEdge();
    }
    
    void addVertex(LevelVertex &v) {
      size_t s = v.connect();
      
      if(s == v.getId()) {
        vertices.push_back(SharedPtr<RoomVertex>(new RoomVertexIndirect(v)));
        addEdge();
      }
      else {
        if(vertices.empty()) {
          LevelVertex v2(v.getProvider(), s, v.getParent());
          
          vertices.push_back(SharedPtr<RoomVertex>(new RoomVertexIndirect(v2)));
          vertices.push_back(SharedPtr<RoomVertex>(new RoomVertexIndirect(v)));
        }
        else {
          LevelVertex v2(v.getProvider(), s, v.getParent());
          
          vertices.push_back(SharedPtr<RoomVertex>(new RoomVertexIndirect(v)));
          addEdge();
          vertices.push_back(SharedPtr<RoomVertex>(new RoomVertexIndirect(v2)));
        }
      }
    }
    
    void close() {
      if(vertices.size() >= 2)
        edges.push_back(Edge(LevelVertex(this, vertices.size()-1, this), LevelVertex(this, 0, this)));
    }
    
    Polygon getPolygon() const {
      Polygon polygon;
      
      for(std::vector<SharedPtr<RoomVertex> >::const_iterator v = vertices.begin(); v != vertices.end(); v++)
        polygon.push_back(***v);
      
      return polygon;
    }
    
    virtual bool hit(const Vertex &v) const {return getPolygon().contains(v);}
    virtual int getPriority() const {return 0;}
    
    virtual std::vector<SharedPtr<LevelObject> > getChildren();
    
    virtual const char* getType() const {
      return "Room";
    }
    
    virtual bool canMove() const {return true;}
    
    virtual void move(float x, float y) {
      Vertex m(x, y);
      
      for(std::vector<SharedPtr<RoomVertex> >::iterator v = vertices.begin(); v != vertices.end(); v++)
        **v += m;
    }
    
    virtual bool canRotate() const {return true;}
    
    virtual void rotate(Vertex m, float a);
    
    virtual const Vertex* getVertex(size_t id) const {
      return &**vertices[id];
    }
    
    virtual size_t getVertexCount() const {
      return vertices.size();
    }
    
    virtual void moveVertex(size_t id, float x, float y) {
      *vertices[id] += Vertex(x, y);
    }
    
    virtual void rotateVertex(size_t id, Vertex m, float a) {
      rotate(m, a);
    }
    
    virtual const Edge* getEdge(size_t id) const {
      return &edges[id];
    }
    
    virtual size_t getEdgeCount() const {
      return edges.size();
    }
    
    virtual void moveEdge(size_t id, float x, float y) {
      moveVertex(id, x, y);
      moveVertex((id+1)%vertices.size(), x, y);
    }
    
    virtual void rotateEdge(size_t id, Vertex m, float a) {
      rotate(m, a);
    }
};

#endif /*ROOM_H_*/