Subdivision des bâtiments : râté.

all_includes.hh

@@ -13,6 +13,7 @@ class Chose;
 #include <set>
 #include <map>
 #include <list>
+#include <queue>
 
 #include <SDL/SDL.h>
 #include <GL/glew.h>

main.cpp

@@ -12,32 +12,6 @@ int main() {
 	c->triangulation();
 	c->updateAABB();
 
-	WallVertex* wvne = new WallVertex(ne);
-	WallVertex* wvse = new WallVertex(se);
-	WallVertex* wvsw = new WallVertex(sw);
-	WallVertex* wvnw = new WallVertex(nw);
-	Wall* wn = new Wall(wvnw,wvne);
-	Wall* we = new Wall(wvne,wvse);
-	Wall* ws = new Wall(wvse,wvsw);
-	Wall* ww = new Wall(wvsw,wvnw);
-	WallVertex* wvn = wn->randomPos(Chose::initialSeed, 0, 1.f/3.f, 2.f/3.f);
-	WallVertex* wvs = ws->randomPos(Chose::initialSeed, 1, 1.f/3.f, 2.f/3.f);
-	Wall* cut = new Wall(wvn, wvs);
-	Wall* cut2 = new Wall(wvn, wvse);
-
-	Wall::iterator it;
-	for (it = wn->begin(); it != wn->end(); ++it)
-		std::cout << (Vertex)(*(*it)) << std::endl;
-
-	(void) wn;
-	(void) we;
-	(void) ws;
-	(void) ww;
-	(void) wvn;
-	(void) wvs;
-	(void) cut;
-	(void) cut2;
-
 	new View(c);
 	return 0;
 }

rules/architecture/batiment.cpp

@@ -1,11 +1,107 @@
 #include "all_includes.hh"
 
+Mur::Mur(Segment _s) : s(_s) {}
+
+void Mur::addSplitPoint(float position) {
+	(void)position;
+}
+
+bool Mur::addDoor(float start, float end) {
+	(void)start; (void)end;
+	return true;
+}
+
+bool Mur::addWindow(float start, float end) {
+	(void)start; (void)end;
+	return true;
+}
+
+Piece::Piece(Quad _c, Mur* n, Mur* e, Mur* s, Mur* w) : c(_c) {
+	murs[0] = n;
+	murs[1] = e;
+	murs[2] = s;
+	murs[3] = w;
+}
+
 BatimentQuad_::BatimentQuad_(Quad _c) : Chose(), c(_c) {
 	addEntropy(c);
 }
 
 bool BatimentQuad_::split() {
-	Quad ch = c.offsetNormal(Dimensions::hauteurEtage);
+	unsigned int trynumber = 0;
+	unsigned int tryseed = hash2(seed, trynumber);
+	std::queue<Piece*> queue;
+	for (int i = 0; i < 4; i++)
+		murs.push_back(new Mur(Segment(c[NE+i], c[SE+i])));
+	queue.push(new Piece(c, murs[0], murs[1], murs[2], murs[3]));
+
+	// TODO : placer la porte d'entrée ?
+
+	Piece* piece;
+	while (!queue.empty()) {
+		piece = queue.front(); queue.pop();
+		pieces.push_back(piece);
+		if (piece->c.surface() < 14 * 100 * 100)
+			continue;
+		switch (hash2(tryseed, 0) % 2) {
+		case 0: { // rectangle
+			if (piece->c.surface() > 100 * 100 * 100 && piece->c.minLength() > 10) {
+				float size = piece->c.minLength() / 3.f;
+				Quad takeN = piece->c.inset(N, size);
+				Quad takeS = takeN.inset(S, size);
+				Quad takeE = takeS.inset(E, size);
+				Quad takeW = takeS.inset(W, size);
+				Quad q[4];
+				q[N] = Quad(piece->c[NE], takeN[NE], takeN[NW], piece->c[NW]);
+				q[E] = Quad(takeS[SE], takeE[SE], takeE[NE], takeS[NE]);
+				q[S] = Quad(piece->c[SW], takeS[SW], takeS[SE], piece->c[SW]);
+				q[W] = Quad(takeS[NW], takeW[NW], takeW[SW], takeS[SW]);
+				Quad qC = takeW;
+				Mur* m[4];
+				m[N] = new Mur(Segment(q[N][SW], q[N][SE]));
+				m[E] = new Mur(Segment(q[E][SW], q[E][SE]));
+				m[S] = new Mur(Segment(q[S][SW], q[S][SE]));
+				m[W] = new Mur(Segment(q[W][SW], q[W][SE]));
+				Piece* p[4];
+				p[N] = new Piece(q[N], piece->murs[N], piece->murs[E], m[N], piece->murs[W]);
+				p[E] = new Piece(q[E], piece->murs[E], m[S], m[E], m[N]);
+				p[S] = new Piece(q[S], piece->murs[S], piece->murs[W], m[S], piece->murs[E]);
+				p[W] = new Piece(q[W], piece->murs[W], m[N], m[W], m[S]);
+				Piece* pC = new Piece(qC, m[N], m[E], m[S], m[W]);
+				for (int i = 0; i < 4; i++) {
+					murs.push_back(m[N+i]);
+					queue.push(p[N+i]);
+				}
+				queue.push(pC);
+				// TODO connecter les pièces avec des addDoor (sur les murs les séparant, et/ou à la pièce centrale) ???
+				break;
+			}
+		}
+		case 1: // donut
+		default: {
+			Cardinal offset = piece->c.maxLengthSide();
+			Vertex n = Segment(piece->c[NW + offset], piece->c[NE + offset]).randomPos(tryseed, 1, 1.f/3.f, 2.f/3.f);
+			Vertex s = Segment(piece->c[SE + offset], piece->c[SW + offset]).randomPos(tryseed, 1, 1.f/3.f, 2.f/3.f);
+			piece->murs[offset]->addSplitPoint(0); // TODO
+			piece->murs[offset+2]->addSplitPoint(0); // TODO
+			Mur* mur = new Mur(Segment(n, s));
+			Piece* p1 = new Piece(Quad(n, piece->c[NE+offset], piece->c[SE+offset], s), piece->murs[offset], piece->murs[offset+1], piece->murs[offset+2], mur);
+			Piece* p2 = new Piece(Quad(s, piece->c[SW+offset], piece->c[NW+offset], n), piece->murs[offset+2], piece->murs[offset+3], piece->murs[offset], mur);
+			murs.push_back(mur);
+			queue.push(p1);
+			queue.push(p2);
+			// TODO : addDoor(start, end); sur le mur les séparant. ?
+			break;
+		}
+		}
+	}
+
+	std::vector<Piece*>::iterator it;
+	for (it = pieces.begin(); it != pieces.end(); ++it) {
+		Quad c = (*it)->c.insetNESW(50);
+		addGPUQuad(c, Couleurs::cielHaut);
+	}
+	//Quad ch = c.offsetNormal(Dimensions::hauteurEtage);
 	//addChild(new ToitQuad(ch, Dimensions::hauteurToit));
 	return true;
 }

rules/architecture/batiment.hh

@@ -3,8 +3,28 @@
 
 #include "all_includes.hh"
 
+class Mur {
+private:
+	std::map<float,Segment> objets;
+	Segment s;
+public:
+	Mur(Segment _s);
+	void addSplitPoint(float position);
+	bool addDoor(float start, float end);
+	bool addWindow(float start, float end);
+};
+
+class Piece {
+public:
+	Quad c;
+	Mur* murs[4];
+	Piece(Quad _c, Mur* n, Mur* e, Mur* s, Mur* w);
+};
+
 class BatimentQuad_ : public Chose {
 	Quad c;
+	std::vector<Piece*> pieces;
+	std::vector<Mur*> murs;
 public:
 	BatimentQuad_(Quad _c);
 	virtual bool split();