Ajout de architecture/quartier.cpp .
This commit is contained in:
Georges Dupéron
parent
c06923105d
commit
e348a945d3
|
|
@ -36,6 +36,7 @@ class Chose;
|
|||
|
||||
#include "rules/architecture/arche.hh"
|
||||
#include "rules/architecture/toit.hh"
|
||||
#include "rules/architecture/quartier.hh"
|
||||
|
||||
#include "rules/batiment/batimentquad.hh"
|
||||
#include "rules/batiment/batimentquadmaison.hh"
|
||||
|
|
|
|||
|
|
@ -111,22 +111,6 @@ const CoteTriangle LEFTSIDE = CoteTriangle(0);
|
|||
const CoteTriangle RIGHTSIDE = CoteTriangle(1);
|
||||
const CoteTriangle BASE = CoteTriangle(2);
|
||||
|
||||
/*
|
||||
enum SommetTriangle {
|
||||
LEFT = 0,
|
||||
TOP = 1,
|
||||
RIGHT = 2
|
||||
};
|
||||
|
||||
inline SommetTriangle operator+(SommetTriangle c, int i) {
|
||||
return SommetTriangle((((int(c) + int(i)) % 3 ) + 3) % 3);
|
||||
}
|
||||
|
||||
inline SommetTriangle operator-(SommetTriangle c, int i) {
|
||||
return SommetTriangle((((int(c) - int(i)) % 3 ) + 3) % 3);
|
||||
}
|
||||
*/
|
||||
|
||||
// Plus ou moins la même chose que CoteTriangle.
|
||||
class SommetTriangle {
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -93,20 +93,46 @@ float Quad::maxLength() const {
|
|||
return std::max(maxLengthNS(), maxLengthEW());
|
||||
}
|
||||
|
||||
float Quad::angle(Coin corner) const {
|
||||
return Triangle(c[NW+corner], c[NE+corner], c[SE+corner]).angle();
|
||||
}
|
||||
|
||||
float Quad::minAngle() const {
|
||||
float a = 370; // > 360.
|
||||
for (int i = 0; i < 4; i++) {
|
||||
a = std::min(a, Triangle(c[NE+i], c[SE+i], c[SW+i]).angle());
|
||||
}
|
||||
return a;
|
||||
float ane = angle(NE);
|
||||
float ase = angle(SE);
|
||||
float asw = angle(SW);
|
||||
float anw = 2*Angle::Pi - (ane + ase + asw);
|
||||
return std::min(std::min(ane, ase), std::min(asw, anw));
|
||||
}
|
||||
|
||||
float Quad::maxAngle() const {
|
||||
float a = 0;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
a = std::max(a, Triangle(c[NE+i], c[SE+i], c[SW+i]).angle());
|
||||
}
|
||||
return a;
|
||||
float ane = angle(NE);
|
||||
float ase = angle(SE);
|
||||
float asw = angle(SW);
|
||||
float anw = 2*Angle::Pi - (ane + ase + asw);
|
||||
return std::max(std::max(ane, ase), std::max(asw, anw));
|
||||
}
|
||||
|
||||
Coin Quad::minAngleCorner() const {
|
||||
float ane = angle(NE);
|
||||
float ase = angle(SE);
|
||||
float asw = angle(SW);
|
||||
float anw = 2*Angle::Pi - (ane + ase + asw);
|
||||
if (ane < ase && ane < asw && ane < anw) return NE;
|
||||
else if (ase < asw && ase < anw) return SE;
|
||||
else if (asw < anw) return SW;
|
||||
else return NW;
|
||||
}
|
||||
|
||||
Coin Quad::maxAngleCorner() const {
|
||||
float ane = angle(NE);
|
||||
float ase = angle(SE);
|
||||
float asw = angle(SW);
|
||||
float anw = 2*Angle::Pi - (ane + ase + asw);
|
||||
if (ane > ase && ane > asw && ane > anw) return NE;
|
||||
else if (ase > asw && ase > anw) return SE;
|
||||
else if (asw > anw) return SW;
|
||||
else return NW;
|
||||
}
|
||||
|
||||
Quad operator+(const Quad& q, const Vertex& v) {
|
||||
|
|
|
|||
|
|
@ -35,8 +35,11 @@ class Quad {
|
|||
float maxLengthEW() const;
|
||||
float minLength() const;
|
||||
float maxLength() const;
|
||||
float angle(Coin corner) const;
|
||||
float minAngle() const;
|
||||
float maxAngle() const;
|
||||
Coin minAngleCorner() const;
|
||||
Coin maxAngleCorner() const;
|
||||
Vertex randomPoint(int seed, int n) const;
|
||||
float surface() const;
|
||||
//void cutCornerCorner(Coin from) const;
|
||||
|
|
|
|||
|
|
@ -28,6 +28,24 @@ float Triangle::maxAngle() const {
|
|||
return std::max(std::max(al, at), ar);
|
||||
}
|
||||
|
||||
SommetTriangle Triangle::maxAngleCorner() const {
|
||||
float at = angle();
|
||||
float ar = Triangle(c[TOP],c[RIGHT],c[LEFT]).angle();
|
||||
float al = Angle::Pi - at - ar;
|
||||
if (al > at && al > ar) return LEFT;
|
||||
else if (at > ar) return TOP;
|
||||
else return RIGHT;
|
||||
}
|
||||
|
||||
SommetTriangle Triangle::minAngleCorner() const {
|
||||
float at = angle();
|
||||
float ar = Triangle(c[TOP],c[RIGHT],c[LEFT]).angle();
|
||||
float al = Angle::Pi - at - ar;
|
||||
if (al < at && al < ar) return LEFT;
|
||||
else if (at < ar) return TOP;
|
||||
else return RIGHT;
|
||||
}
|
||||
|
||||
float Triangle::minLength() const {
|
||||
return std::min(std::min((c[LEFT] - c[TOP]).norm(), (c[TOP] - c[RIGHT]).norm()), (c[RIGHT] - c[LEFT]).norm());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,9 +24,11 @@ public :
|
|||
}
|
||||
friend Triangle operator+(const Triangle& t, const Vertex& v);
|
||||
float cosAngle() const; // cosinus de l'angle en c[1].
|
||||
float angle() const; // angle en c[1], en degrés. TODO : le calcul ne donne que des angles entre 0 et 180 !
|
||||
float angle() const; // angle en c[TOP], en degrés.
|
||||
float minAngle() const; // angle minimum du triangle (en LEFT, TOP ou RIGHT).
|
||||
float maxAngle() const; // angle maximum du triangle (en LEFT, TOP ou RIGHT).
|
||||
SommetTriangle minAngleCorner() const;
|
||||
SommetTriangle maxAngleCorner() const;
|
||||
float minLength() const;
|
||||
float maxLength() const;
|
||||
float surface() const;
|
||||
|
|
|
|||
|
|
@ -32,12 +32,10 @@ float ArcheQuad::f(float x) {
|
|||
}
|
||||
}
|
||||
|
||||
// Fonction fausse
|
||||
float ArcheQuad::ogive(float x) {
|
||||
return sin(acos(abs(x / 2.f) + 1.f/2.f));
|
||||
}
|
||||
|
||||
// Fonction fausse
|
||||
float ArcheQuad::berceau(float x) {
|
||||
return sin(acos(x));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,9 +19,9 @@ public:
|
|||
float berceau(float x);
|
||||
private:
|
||||
// TODO : couleur de l'arche
|
||||
static const char r = 0xF1;
|
||||
static const char g = 0xE0;
|
||||
static const char b = 0xE0;
|
||||
static const char r = 0xF1; // TODO : factoriser cette couleur (couleur des murs des faux bâtiments).
|
||||
static const char g = 0xE3;
|
||||
static const char b = 0xAD;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
214
rules/architecture/quartier.cpp
Normal file
214
rules/architecture/quartier.cpp
Normal file
|
|
@ -0,0 +1,214 @@
|
|||
#include "all_includes.hh"
|
||||
|
||||
QuartierQuad_::QuartierQuad_(Quad _c) : c(_c) {
|
||||
addEntropy(c);
|
||||
}
|
||||
|
||||
void QuartierQuad_::getBoundingBoxPoints() {
|
||||
addBBPoints(c, 6000); // TODO : factoriser cette longueur (hauteur max des bâtiments).
|
||||
}
|
||||
|
||||
bool QuartierQuad_::split() {
|
||||
bool small = c.minLength() < 3500;
|
||||
bool big = c.maxLength() >= 6000;
|
||||
bool isConcave = c.maxAngle() > Angle::d2r(160);
|
||||
bool anglesOk = c.minAngle() > Angle::d2r(90-40) && c.maxAngle() < Angle::d2r(90+40);
|
||||
bool tooWideX = c.minLengthEW() * 2 < c.maxLengthNS(); // trop allongé (côté E ou W deux fois plus petit que le côté N ou S).
|
||||
bool tooWideY = c.minLengthNS() * 2 < c.maxLengthEW(); // trop allongé (côté N ou S deux fois plus petit que le côté E ou W).
|
||||
if (isConcave)
|
||||
concave();
|
||||
else if (!big && proba(seed, -1, 1, 20))
|
||||
batiments();
|
||||
else if (!small && !anglesOk)
|
||||
angleAngle(); // TODO
|
||||
else if (!small && tooWideY)
|
||||
rect(); // TODO : Quad(c[NW], c[NE], c[SE], c[SW])
|
||||
else if (!small && tooWideX)
|
||||
rect(); // TODO : fusion avec ci-dessus
|
||||
else if (!small)
|
||||
carre();
|
||||
else
|
||||
batiments();
|
||||
return true;
|
||||
}
|
||||
|
||||
void QuartierQuad_::triangulation() {
|
||||
Quad ci = c.insetNESW(250 + 140); // TODO : factoriser cette longueur (largeur route + largeur trottoir).
|
||||
Quad cih = c.offsetNormal(6000); // TODO : factoriser cette longueur (hauteur max des bâtiments).
|
||||
addGPUQuad(c, 0x36, 0x36, 0x36); // TODO : factoriser cette couleur (couleur de la route).
|
||||
addGPUQuad(cih, 0xF1, 0xE0, 0xE0); // TODO : factoriser cette couleur (couleur des toits).
|
||||
for (int i = 0; i < 4; i++)
|
||||
addGPUQuad(Quad(ci[NE+i], ci[SE+i], cih[SE+i], cih[NE+i]), 0xF1, 0xE3, 0xAD); // TODO : factoriser cette couleur (couleur des murs des faux bâtiments).
|
||||
}
|
||||
|
||||
void QuartierQuad_::concave() {
|
||||
// TODO
|
||||
}
|
||||
|
||||
void QuartierQuad_::angleCote() {
|
||||
Quad q = c << c.maxAngleCorner();
|
||||
Vertex s = Segment(q[SE], q[SW]).randomPos(seed, 1, 0.4f, 0.6f);
|
||||
Vertex w = Segment(q[SW], q[NW]).randomPos(seed, 0, 0.4f, 0.6f);
|
||||
Triangle ts(q[SE], s, q[NE]);
|
||||
Triangle tw(q[NE], w, q[NW]);
|
||||
if (ts.minAngle() > tw.minAngle()) {
|
||||
addChild(new QuartierTri_(ts));
|
||||
addChild(new QuartierQuad_(Quad(q[NE], s, q[SW], q[NW])));
|
||||
} else {
|
||||
addChild(new QuartierTri_(tw));
|
||||
addChild(new QuartierQuad_(Quad(q[NE], q[SE], q[SW], w)));
|
||||
}
|
||||
}
|
||||
|
||||
void QuartierQuad_::angleAngle() {
|
||||
Quad q = c << c.maxAngleCorner();
|
||||
addChild(new QuartierTri_(Triangle(q[NE], q[SE], q[SW])));
|
||||
addChild(new QuartierTri_(Triangle(q[SW], q[NW], q[NE])));
|
||||
}
|
||||
|
||||
void QuartierQuad_::rect() {
|
||||
Vertex n = Segment(c[NW], c[NE]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f);
|
||||
Vertex s = Segment(c[SE], c[SW]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f);
|
||||
|
||||
addChild(new QuartierQuad_(Quad(c[NE], c[SE], s, n)));
|
||||
addChild(new QuartierQuad_(Quad(c[SW], c[NW], n, s)));
|
||||
}
|
||||
|
||||
void QuartierQuad_::carre() {
|
||||
// TODO : insetProportionnal();
|
||||
Vertex center = c.insetNESW(c.minLength() / 4.f).randomPoint(seed, 0);
|
||||
Vertex middle[4];
|
||||
for (int i = 0; i < 4; i++)
|
||||
middle[N+i] = Segment(c[NW+i], c[NE+i]).randomPos(seed, i + 1, 0.25, 0.75);
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
addChild(new QuartierQuad_(Quad(c[NE+i], middle[E+i], center, middle[N+i])));
|
||||
}
|
||||
|
||||
void QuartierQuad_::batiments() {
|
||||
float hauteurTrottoir = 20; // TODO : factoriser + ajouter ça à la hauteur max d'un bâtiment dans les autres calculs.
|
||||
Quad qtrottoir = c.insetNESW(250);
|
||||
Quad qinterieur = qtrottoir.insetNESW(140);
|
||||
Quad qbatiments = qinterieur.offsetNormal(hauteurTrottoir);
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
addChild(new RouteQuadChaussee(Quad(c[NE+i],c[SE+i],qtrottoir[SE+i],qtrottoir[NE+i])));
|
||||
addChild(new TrottoirQuadNormal(Quad(qtrottoir[NE+i],qtrottoir[SE+i],qinterieur[SE+i],qinterieur[NE+i]),hauteurTrottoir));
|
||||
}
|
||||
|
||||
// TODO :
|
||||
|
||||
bool small = c.minLength() < 2500;
|
||||
bool big = c.maxLength() >= 5000;
|
||||
bool anglesAcceptable = c.minAngle() > Angle::d2r(90-60) && c.maxAngle() < Angle::d2r(90+60);
|
||||
|
||||
if (!big && proba(seed, 0, 1, 20)) {
|
||||
addChild(new TerrainQuadHerbe(qbatiments));
|
||||
} else if (small && anglesAcceptable) {
|
||||
addChild(new BatimentQuad(qbatiments));
|
||||
} else {
|
||||
addChild(new TerrainQuadHerbe(qbatiments));
|
||||
}
|
||||
}
|
||||
|
||||
QuartierTri_::QuartierTri_(Triangle _c) : c(_c) {
|
||||
addEntropy(c);
|
||||
}
|
||||
|
||||
void QuartierTri_::getBoundingBoxPoints() {
|
||||
addBBPoints(c, 6000); // TODO : factoriser cette longueur (hauteur max des bâtiments).
|
||||
}
|
||||
|
||||
bool QuartierTri_::split() {
|
||||
bool small = c.minLength() < 5000;
|
||||
bool big = c.maxLength() >= 10000;
|
||||
float minAngle = c.minAngle();
|
||||
float maxAngle = c.maxAngle();
|
||||
bool equilateral = maxAngle < Angle::d2r(60+15) && minAngle > Angle::d2r(60-15);
|
||||
bool angleObtus = maxAngle > Angle::d2r(120);
|
||||
bool angleAigu = minAngle < Angle::d2r(30);
|
||||
bool anglesAcceptable = !angleAigu && !angleObtus;
|
||||
if (!big && proba(seed, -1, 1, 20)) {
|
||||
batiments(); // TODO : RouteTrottoirTri(c);
|
||||
} else if (big && anglesAcceptable) {
|
||||
switch (hash2(seed, -2) % 3) {
|
||||
case 0: centre(); break;
|
||||
case 1: hauteur(); break;
|
||||
case 2:
|
||||
default: trapeze(); break;
|
||||
}
|
||||
} else if (!small && equilateral) {
|
||||
centre();
|
||||
} else if (!small && angleObtus) {
|
||||
hauteur();
|
||||
} else if (!small) {
|
||||
trapeze();
|
||||
} else {
|
||||
batiments();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void QuartierTri_::triangulation() {
|
||||
Triangle ci = c.insetLTR(250 + 140); // TODO : factoriser cette longueur (largeur route + largeur trottoir).
|
||||
Triangle cih = c.offsetNormal(6000); // TODO : factoriser cette longueur (hauteur max des bâtiments).
|
||||
addGPUTriangle(c, 0x36, 0x36, 0x36); // TODO : factoriser cette couleur (couleur de la route).
|
||||
addGPUTriangle(cih, 0xF1, 0xE0, 0xE0); // TODO : factoriser cette couleur (couleur des toits).
|
||||
for (int i = 0; i < 3; i++)
|
||||
addGPUQuad(Quad(ci[LEFT+i], ci[TOP+i], cih[TOP+i], cih[LEFT+i]), 0xF1, 0xE3, 0xAD); // TODO : factoriser cette couleur (couleur des murs des faux bâtiments).
|
||||
}
|
||||
|
||||
void QuartierTri_::centre() {
|
||||
// TODO : maxLength / 6 au lieu de 1000
|
||||
// TODO : insetProportionnal();
|
||||
Vertex center = c.insetLTR(c.maxLength() / 6).randomPoint(seed, 0);
|
||||
Vertex edge[3];
|
||||
for (int i = 0; i < 3; i++)
|
||||
edge[LEFTSIDE+i] = Segment(c[LEFT+i], c[TOP+i]).randomPos(seed, i+1, 1.f/3.f, 2.f/3.f);
|
||||
|
||||
for (int i = 0; i < 3; i++)
|
||||
addChild(new QuartierQuad_(Quad(c[TOP+i], edge[RIGHTSIDE+i], center, edge[LEFTSIDE+i])));
|
||||
}
|
||||
|
||||
void QuartierTri_::hauteur() {
|
||||
Triangle t = c << c.maxAngleCorner();
|
||||
Vertex opposite = Segment(t[TOP], t[RIGHT]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f);
|
||||
|
||||
addChild(new QuartierTri_(Triangle(t[TOP], opposite, t[LEFT])));
|
||||
addChild(new QuartierTri_(Triangle(t[LEFT], opposite, t[RIGHT])));
|
||||
}
|
||||
|
||||
void QuartierTri_::trapeze() {
|
||||
Triangle t = c << c.minAngleCorner();
|
||||
Vertex left = Segment(t[LEFT], t[TOP]).randomPos(seed, 0, 1.f/3.f, 2.f/3.f);
|
||||
Vertex base = Segment(t[RIGHT], t[LEFT]).randomPos(seed, 1, 1.f/3.f, 2.f/3.f);
|
||||
|
||||
addChild(new QuartierTri_(Triangle(base, t[TOP], left)));
|
||||
addChild(new QuartierQuad_(Quad(left, t[TOP], t[RIGHT], base)));
|
||||
}
|
||||
|
||||
void QuartierTri_::batiments() {
|
||||
float hauteurTrottoir = 20; // TODO : factoriser + ajouter ça à la hauteur max d'un bâtiment dans les autres calculs.
|
||||
Triangle ttrottoir = c.insetLTR(250);
|
||||
Triangle tinterieur = ttrottoir.insetLTR(140);
|
||||
Triangle tbatiments = tinterieur.offsetNormal(hauteurTrottoir);
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
addChild(new RouteQuadChaussee(Quad(c[LEFT+i],c[TOP+i],ttrottoir[TOP+i],ttrottoir[LEFT+i])));
|
||||
addChild(new TrottoirQuadNormal(Quad(ttrottoir[LEFT+i],ttrottoir[TOP+i],tinterieur[TOP+i],tinterieur[LEFT+i]),hauteurTrottoir));
|
||||
}
|
||||
|
||||
// TODO :
|
||||
|
||||
bool small = tbatiments.minLength() < 3000;
|
||||
bool big = tbatiments.maxLength() >= 5000;
|
||||
bool anglesAcceptable = tbatiments.minAngle() > Angle::d2r(30) && tbatiments.maxAngle() < Angle::d2r(120);
|
||||
|
||||
if (!big && proba(seed, 0, 1, 20)) {
|
||||
addChild(new TerrainTriHerbe(tbatiments));
|
||||
} else if (small && anglesAcceptable) {
|
||||
addChild(new BatimentTri(tbatiments));
|
||||
} else {
|
||||
addChild(new TerrainTriHerbe(tbatiments));
|
||||
}
|
||||
}
|
||||
38
rules/architecture/quartier.hh
Normal file
38
rules/architecture/quartier.hh
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
#ifndef _RULES_ARCHITECTURE_QUARTIER_HH_
|
||||
#define _RULES_ARCHITECTURE_QUARTIER_HH_
|
||||
|
||||
#include "all_includes.hh"
|
||||
|
||||
class QuartierQuad_: public Chose {
|
||||
private:
|
||||
Quad c;
|
||||
public:
|
||||
QuartierQuad_(Quad _c);
|
||||
virtual void getBoundingBoxPoints();
|
||||
virtual bool split();
|
||||
virtual void triangulation();
|
||||
private:
|
||||
void concave();
|
||||
void angleAngle();
|
||||
void angleCote();
|
||||
void rect();
|
||||
void carre();
|
||||
void batiments();
|
||||
};
|
||||
|
||||
class QuartierTri_: public Chose {
|
||||
private:
|
||||
Triangle c;
|
||||
public:
|
||||
QuartierTri_(Triangle _c);
|
||||
virtual void getBoundingBoxPoints();
|
||||
virtual bool split();
|
||||
virtual void triangulation();
|
||||
private:
|
||||
void centre();
|
||||
void hauteur();
|
||||
void trapeze();
|
||||
void batiments();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
#include "all_includes.hh"
|
||||
|
||||
// TODO : les x.insetNESW_LTR(x.minLength() / 3.f) sont faux (on risque d'avoir un triangle plus petit qu'1/3), il faudrait une fonction inset qui prend un float entre 0 et 1.
|
||||
// TODO : les x.insetNESW_LTR(x.minLength() / 3.f) sont faux (on risque d'avoir un triangle plus petit qu'⅓), il faudrait une fonction inset qui prend un float entre 0 et 1.
|
||||
|
||||
ToitQuad::ToitQuad(Quad _c, float _height) : Chose(), c(_c), height(_height) {
|
||||
addEntropy(c);
|
||||
|
|
@ -15,7 +15,7 @@ void ToitQuad::triangulation() {
|
|||
switch (hash2(seed, -1) % 4) {
|
||||
case 0: pointCentral(); break;
|
||||
case 1: deuxPoints(); break;
|
||||
case 2: deuxPointsVerticaux();
|
||||
case 2: deuxPointsVerticaux(); break;
|
||||
case 3:
|
||||
default: plat(); break;
|
||||
}
|
||||
|
|
|
|||
71
tiles.md
71
tiles.md
|
|
@ -1,44 +1,41 @@
|
|||
Rules
|
||||
=====
|
||||
Déjà fait
|
||||
=========
|
||||
|
||||
* toit
|
||||
* quad : point central, deux points, deux points verticalement au-dessus des murs, plat.
|
||||
* tri : point central, trois points, un points verticalement au-dessus des murs, deux points verticaux, plat.
|
||||
* arche
|
||||
* en berceau
|
||||
* d'ogive
|
||||
* quartier
|
||||
* quad : concave, angleAngle angleCote, rectangle, carre, (contient route + trottoir)
|
||||
* tri : centre, hauteur, trapeze, batiments (contient route + trottoir)
|
||||
|
||||
À faire
|
||||
=======
|
||||
|
||||
* chose
|
||||
* batiment
|
||||
* batimentquad (sorte de factory interne, fait un addChild : trottoirs (chosit le bon type), jardin (choisir le bon type, batimentquadmaison ou batimentquadimmeuble ou …)
|
||||
* batimentquadmaison
|
||||
* batimentquadimmeuble
|
||||
* etagequad (factory, représente un étage d'une maison ou d'un immeuble par ex).
|
||||
* piecequad (factory, représente une pièce d'un étage)
|
||||
* ouverturequad (factory, paramètre décide si porte ou fenêtre, génère 2 ou 3 modèles de portes ou fenêtre)
|
||||
* pareil pour les tri et penta
|
||||
* ponts, ponts avec maison au-dessus, …
|
||||
* jardin
|
||||
* cour intérieure
|
||||
* 1 étage, 2 étages, immeuble
|
||||
* étages
|
||||
* découpage en pièces
|
||||
* position des portes, fenêtres, escaliers
|
||||
* mobilier (intérieur et extérieur)
|
||||
* murs
|
||||
* portes
|
||||
* fenêtres
|
||||
* escalier
|
||||
* table
|
||||
* statue
|
||||
* chaises
|
||||
* banc
|
||||
* quartier
|
||||
* quartierquad (factory)
|
||||
* quartierquadangle
|
||||
* quartierquadcarre
|
||||
* quartierquadrect
|
||||
* quartiertri (factory)
|
||||
* quartiertrihauteur (coupe le triangle selon sa hauteur)
|
||||
* quartiertriverscarre (coupe un coin du triangle pour en faire un carré)
|
||||
* quartiertriverspenta (coupe un coin du triangle pour en faire un pentagone)
|
||||
* quartierpenta (factory)
|
||||
* quelques motifs quartierpenta*
|
||||
* quelques motifs qui prévoient des ponts
|
||||
* route
|
||||
* routequad (factory, paramètre indique si l'on veut un carrefour ou une chaussee ou …)
|
||||
* routequadcarrefour
|
||||
* routequadchaussee
|
||||
* routequadparking
|
||||
* trottoirquad (factory, paramètre indique s'il faut un bateau, …)
|
||||
* trottoirquadnormal
|
||||
* trottoirquadbas (la partie basse du bateau)
|
||||
* trottoirquadpente (la pente du bateau)
|
||||
* trottoirquadbateau (se subdivise en 3 trottoirquad* : pente + bas + pente)
|
||||
* un motif pour faire une place
|
||||
* au moins une statue, fontaine ou autre.
|
||||
* quartiers spéciaux
|
||||
* longue route bordée de deux enfilades de maisons (prévoir la place pour un / des bâtiment(s) avec arche dans le sens de la rue).
|
||||
* longue enfilade de maisons bordée de deux routes (prévoir la place pour un / des bâtiment(s) avec arche qui fait un raccourci pour ne pas faire tout le tour).
|
||||
* place (polygone de route d'une couleur différente, avec possiblement un petit bâtiment au milieu).
|
||||
* canaux + ponts + bâtiment(s) avec arche au-dessus.
|
||||
* route + trottoir
|
||||
* terrain
|
||||
* terrainquadherbe
|
||||
* d'autres terrains…
|
||||
* herbe
|
||||
* mettre un peu de relief dans l'herbe
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user