159 lines
4.2 KiB
C++
159 lines
4.2 KiB
C++
#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) {}
|
|
};
|
|
|
|
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);
|
|
}
|
|
};
|
|
|
|
class RoomVertexIndirect : public RoomVertex {
|
|
private:
|
|
LevelVertex vertex;
|
|
|
|
public:
|
|
RoomVertexIndirect(const LevelVertex &v) : vertex(v) {}
|
|
|
|
virtual const Vertex& operator*() const {
|
|
return *vertex;
|
|
}
|
|
};
|
|
|
|
|
|
std::string name;
|
|
float height;
|
|
|
|
std::vector<SharedPtr<RoomVertex> > vertices;
|
|
std::vector<Edge> edges;
|
|
|
|
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);
|
|
|
|
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_*/
|