Added simple elevation painter as well as array syntax for AndConstraint, RandomTerrain and the new MultiPainter.

This was SVN commit r2407.

binaries/data/mods/official/maps/random/test.js

@@ -1,10 +1,11 @@
 const SIZE = 64;
 
-init(SIZE, new RandomTerrain("snow", "snow forest"), 0);
+init(SIZE, ["snow", "snow forest"], 0);
 
 createMulti(
 	new ClumpPlacer(20.0, 0.01, 0.01), 
-	new LayeredPainter([1], ["snow grass 2", "snow grass 2|wrld_flora_pine"]),
+	[new LayeredPainter([1], ["snow grass 2", "snow grass 2|wrld_flora_pine"]), 
+	 new ElevationPainter(3.0)],
 	new AvoidTextureConstraint("snow grass 2"),
 	150,
 	500

binaries/data/mods/official/maps/rmlibrary.js

@@ -4,12 +4,11 @@ const
 TYPE_RECTPLACER = 1,
 TYPE_TERRAINPAINTER = 2,
 TYPE_NULLCONSTRAINT = 3,
-TYPE_RANDOMTERRAIN = 4,
-TYPE_LAYEREDPAINTER = 5,
-TYPE_AVOIDAREACONSTRAINT = 6,
-TYPE_CLUMPPLACER = 7,
-TYPE_AVOIDTEXTURECONSTRAINT = 8,
-TYPE_ANDCONSTRAINT = 9;
+TYPE_LAYEREDPAINTER = 4,
+TYPE_AVOIDAREACONSTRAINT = 5,
+TYPE_CLUMPPLACER = 6,
+TYPE_AVOIDTEXTURECONSTRAINT = 7,
+TYPE_ELEVATIONPAINTER = 8;
 
 // Utility functions
 
@@ -58,11 +57,6 @@ function NullConstraint() {
 	this.TYPE = TYPE_NULLCONSTRAINT;
 }
 
-function RandomTerrain() {
-	this.TYPE = TYPE_RANDOMTERRAIN;
-	this.terrains = argsToArray(arguments);
-}
-
 function LayeredPainter(widths, terrains) {
 	this.TYPE = TYPE_LAYEREDPAINTER;
 	this.widths = widths;
@@ -88,10 +82,9 @@ function AvoidTextureConstraint(texture) {
 	this.texture = texture;
 }
 
-function AndConstraint(a, b) {
-	this.TYPE = TYPE_ANDCONSTRAINT;
-	this.a = a;
-	this.b = b;
+function ElevationPainter(elevation) {
+	this.TYPE = TYPE_ELEVATIONPAINTER;
+	this.elevation = elevation;
 }
 
 function createMulti(centeredPlacer, painter, constraint, num, maxFail) {

source/tools/rmgen/objparse.cpp

@@ -79,12 +79,23 @@ bool ParseArray(JSContext* cx, jsval val, vector<jsval>& ret) {
 }
 
 AreaPainter* ParsePainter(JSContext* cx, jsval val) {
+	vector<jsval> array;
 	jsval jsv, jsv2;
 	Terrain* terrain = 0;
-	vector<jsval> array;
+	float elevation;
 	vector<Terrain*> terrains;
 	vector<int> widths;
 
+	if(ParseArray(cx, val, array)) {
+		// MultiPainter is encoded as an array of painters
+		vector<AreaPainter*> painters(array.size());
+		for(int i=0; i<array.size(); i++) {
+			painters[i] = ParsePainter(cx, array[i]);
+			if(painters[i]==0) return 0;
+		}
+		return new MultiPainter(painters);
+	}
+
 	switch(GetType(cx, val)) {
 		case TYPE_TERRAINPAINTER:
 			if(!GetJsvalField(cx, val, "terrain", jsv)) return 0;
@@ -92,6 +103,10 @@ AreaPainter* ParsePainter(JSContext* cx, jsval val) {
 			if(terrain==0) return 0;
 			return new TerrainPainter(terrain);
 
+		case TYPE_ELEVATIONPAINTER:
+			if(!GetFloatField(cx, val, "elevation", elevation)) return 0;
+			return new ElevationPainter(elevation);
+
 		case TYPE_LAYEREDPAINTER:
 			if(!GetJsvalField(cx, val, "widths", jsv)) return 0;
 			if(!GetJsvalField(cx, val, "terrains", jsv2)) return 0;
@@ -141,12 +156,25 @@ AreaPlacer* ParsePlacer(JSContext* cx, jsval val) {
 }
 
 Constraint* ParseConstraint(JSContext* cx, jsval val) {
-	if(JSVAL_IS_NULL(val)) return new NullConstraint();
-
+	vector<jsval> array;
 	int areaId;
 	string texture;
 	jsval jsv, jsv2;
-	Constraint* c1, *c2;
+
+	if(JSVAL_IS_NULL(val)) {
+		// convenience way of specifying a NullConstraint
+		return new NullConstraint();
+	}
+
+	if(ParseArray(cx, val, array)) {
+		// AndConstraint is encoded as an array of constraints
+		vector<Constraint*> constraints(array.size());
+		for(int i=0; i<array.size(); i++) {
+			constraints[i] = ParseConstraint(cx, array[i]);
+			if(constraints[i]==0) return 0;
+		}
+		return new AndConstraint(constraints);
+	}
 
 	switch(GetType(cx, val)) {
 		case TYPE_NULLCONSTRAINT:
@@ -161,43 +189,30 @@ Constraint* ParseConstraint(JSContext* cx, jsval val) {
 			if(!GetStringField(cx, val, "texture", texture)) return 0;
 			return new AvoidTextureConstraint(theMap->getId(texture));
 
-		case TYPE_ANDCONSTRAINT:
-			if(!GetJsvalField(cx, val, "a", jsv)) return 0;
-			if(!GetJsvalField(cx, val, "b", jsv2)) return 0;
-			if(!(c1 = ParseConstraint(cx, jsv))) return 0;
-			if(!(c2 = ParseConstraint(cx, jsv2))) return 0;
-			return new AndConstraint(c1, c2);
-
 		default:
 			return 0;
 	}
 }
 
 Terrain* ParseTerrain(JSContext* cx, jsval val) {
+	vector<jsval> array;
+
 	if(JSVAL_IS_STRING(val)) {
 		// simple terrains are just encoded as strings
 		string str = JS_GetStringBytes(JS_ValueToString(cx, val));
 		return SimpleTerrain::parse(str);
 	}
-	else {
-		// complex terrain type
-		Terrain* terrain = 0;
-		vector<jsval> array;
-		vector<Terrain*> terrains;
 
-		switch(GetType(cx, val)) {
-			case TYPE_RANDOMTERRAIN:
-				if(!GetArrayField(cx, val, "terrains", array)) return 0;
-				for(int i=0; i<array.size(); i++) {
-					terrain = ParseTerrain(cx, array[i]);
-					if(terrain==0) return 0;
-					terrains.push_back(terrain);
-				}
-				return new RandomTerrain(terrains);
-
-			default:
-				return 0;
+	if(ParseArray(cx, val, array)) {
+		// RandomTerrain is encoded as an array of terrains
+		vector<Terrain*> terrains(array.size());
+		for(int i=0; i<array.size(); i++) {
+			terrains[i] = ParseTerrain(cx, array[i]);
+			if(terrains[i]==0) return 0;
 		}
-		return 0;
+		return new RandomTerrain(terrains);
 	}
+
+	// so far these are the only ways of specifying a terrain
+	return 0;
 }

source/tools/rmgen/objparse.h

@@ -14,12 +14,11 @@ const int
 TYPE_RECTPLACER = 1,
 TYPE_TERRAINPAINTER = 2,
 TYPE_NULLCONSTRAINT = 3,
-TYPE_RANDOMTERRAIN = 4,
-TYPE_LAYEREDPAINTER = 5,
-TYPE_AVOIDAREACONSTRAINT = 6,
-TYPE_CLUMPPLACER = 7,
-TYPE_AVOIDTEXTURECONSTRAINT = 8,
-TYPE_ANDCONSTRAINT = 9;
+TYPE_LAYEREDPAINTER = 4,
+TYPE_AVOIDAREACONSTRAINT = 5,
+TYPE_CLUMPPLACER = 6,
+TYPE_AVOIDTEXTURECONSTRAINT = 7,
+TYPE_ELEVATIONPAINTER = 8;
 
 // Helper functions to parse objects from JS versions
 

source/tools/rmgen/simpleconstraints.cpp

@@ -34,12 +34,22 @@ bool AvoidTextureConstraint::allows(Map* m, int x, int y)
 
 // AndConstraint
 
-AndConstraint::AndConstraint(Constraint* a, Constraint*b) {
-	this->a = a;
-	this->b = b;
+AndConstraint::AndConstraint(const vector<Constraint*>& constraints) {
+	this->constraints = constraints;
+}
+
+AndConstraint::~AndConstraint() {
+	for(int i=0; i<constraints.size(); i++) {
+		delete constraints[i];
+	}
 }
 
 bool AndConstraint::allows(Map* m, int x, int y)
 {
-	return a->allows(m,x,y) && b->allows(m,x,y);
+	for(int i=0; i<constraints.size(); i++) {
+		if(!constraints[i]->allows(m, x, y)) {
+			return false;
+		}
+	}
+	return true;
 }

source/tools/rmgen/simpleconstraints.h

@@ -28,10 +28,10 @@ public:
 
 class AndConstraint : public Constraint {
 private:
-	Constraint* a;
-	Constraint* b;
+	std::vector<Constraint*> constraints;
 public:
-	AndConstraint(Constraint* a, Constraint* b);
+	AndConstraint(const std::vector<Constraint*>& constraints);
+	~AndConstraint();
 	virtual bool allows(Map* m, int x, int y);
 };
 

source/tools/rmgen/simplepainters.cpp

@@ -19,3 +19,36 @@ void TerrainPainter::paint(Map* m, Area* a)
 		terrain->place(m, p.x, p.y);
 	}
 }
+
+// ElevationPainter
+
+ElevationPainter::ElevationPainter(float elevation)
+{
+	this->elevation = elevation;
+}
+
+void ElevationPainter::paint(Map* m, Area* a) 
+{
+	for (int i=0; i<a->points.size(); i++) {
+		Point p = a->points[i];
+		static const int DX[4] = {0,1,1,0};
+		static const int DY[4] = {0,0,1,1};
+		for(int j=0; j<4; j++) {
+			m->height[p.x+DX[j]][p.y+DY[j]] = elevation;
+		}
+	}
+}
+
+// MultiPainter
+
+MultiPainter::MultiPainter(const std::vector<AreaPainter*>& painters) 
+{
+	this->painters = painters;
+}
+
+void MultiPainter::paint(Map* m, Area* a) 
+{
+	for (int i=0; i<painters.size(); i++) {
+		painters[i]->paint(m, a);
+	}
+}

source/tools/rmgen/simplepainters.h

@@ -7,11 +7,24 @@
 #include "terrain.h"
 
 class TerrainPainter : public AreaPainter {
-public:
 	Terrain* terrain;
-
+public:
 	TerrainPainter(Terrain* terrain);
-	void paint(Map* m, Area* a);
+	virtual void paint(Map* m, Area* a);
+};
+
+class ElevationPainter : public AreaPainter {
+	float elevation;
+public:
+	ElevationPainter(float elevation);
+	virtual void paint(Map* m, Area* a);
+};
+
+class MultiPainter : public AreaPainter {
+	std::vector<AreaPainter*> painters;
+public:
+	MultiPainter(const std::vector<AreaPainter*>& painters);
+	virtual void paint(Map* m, Area* a);
 };
 
 #endif