Index: bauer/brueckenbauer.cc
===================================================================
--- bauer/brueckenbauer.cc	(revision 9114)
+++ bauer/brueckenbauer.cc	(working copy)
@@ -930,7 +930,7 @@
 
 void bridge_builder_t::build_ramp(player_t* player, koord3d end, ribi_t::ribi ribi_neu, slope_t::type weg_hang, const bridge_desc_t* desc)
 {
-	assert(weg_hang < 81);
+	assert(weg_hang <= slope_t::raised);
 
 	grund_t *alter_boden = welt->lookup(end);
 	brueckenboden_t *bruecke;
Index: bauer/wegbauer.cc
===================================================================
--- bauer/wegbauer.cc	(revision 9114)
+++ bauer/wegbauer.cc	(working copy)
@@ -941,20 +941,20 @@
 
 		// write middle heights
 		if(  dir == koord::north  ) {
-			*new_from_slope = corner_sw(from_slope) + corner_se(from_slope) * 3 + m_from * 9              + m_from * 27;
-			*new_to_slope =   m_to                + m_to * 3                + corner_ne(to_slope) * 9   + corner_nw(to_slope) * 27;
+			*new_from_slope = corner_sw(from_slope) + corner_se(from_slope) * slope_t::southeast + m_from * slope_t::northeast + m_from * slope_t::northwest;
+			*new_to_slope =   m_to + m_to * slope_t::southeast + corner_ne(to_slope) * slope_t::northeast + corner_nw(to_slope) * slope_t::northwest;
 		}
 		else if(  dir == koord::east  ) {
-			*new_from_slope = corner_sw(from_slope) + m_from * 3              + m_from * 9              + corner_nw(from_slope) * 27;
-			*new_to_slope =   m_to                + corner_se(to_slope) * 3   + corner_ne(to_slope) * 9   + m_to * 27;
+			*new_from_slope = corner_sw(from_slope) + m_from * slope_t::southeast + m_from * slope_t::northeast + corner_nw(from_slope) * slope_t::northwest;
+			*new_to_slope =   m_to + corner_se(to_slope) * slope_t::southeast + corner_ne(to_slope) * slope_t::northeast   + m_to * slope_t::northwest;
 		}
 		else if(  dir == koord::south  ) {
-			*new_from_slope = m_from              + m_from * 3              + corner_ne(from_slope) * 9 + corner_nw(from_slope) * 27;
-			*new_to_slope =   corner_sw(to_slope)   + corner_se(to_slope) * 3   + m_to * 9                + m_to * 27;
+			*new_from_slope = m_from + m_from * slope_t::southeast + corner_ne(from_slope) * slope_t::northeast + corner_nw(from_slope) * slope_t::northwest;
+			*new_to_slope =   corner_sw(to_slope) + corner_se(to_slope) * slope_t::southeast   + m_to * slope_t::northeast + m_to * slope_t::northwest;
 		}
 		else if(  dir == koord::west  ) {
-			*new_from_slope = m_from              + corner_se(from_slope) * 3 + corner_ne(from_slope) * 9 + m_from * 27;
-			*new_to_slope =   corner_sw(to_slope)   + m_to * 3                + m_to * 9                + corner_nw(to_slope) * 27;
+			*new_from_slope = m_from + corner_se(from_slope) * slope_t::southeast + corner_ne(from_slope) * slope_t::northeast + m_from * slope_t::northwest;
+			*new_to_slope =   corner_sw(to_slope) + m_to * slope_t::southeast + m_to * slope_t::northeast + corner_nw(to_slope) * slope_t::northwest;
 		}
 		return true;
 	}
Index: boden/grund.cc
===================================================================
--- boden/grund.cc	(revision 9114)
+++ boden/grund.cc	(working copy)
@@ -249,6 +249,12 @@
 			// truncate double slopes to single slopes, better than nothing
 			sl = min( corner_sw(slope), 1 ) + min( corner_se(slope), 1 ) * 2 + min( corner_ne(slope), 1 ) * 4 + min( corner_nw(slope), 1 ) * 8;
 		}
+		/* INSERT LOGIC TO SAVE TO DOUBLE HEIGHTS
+		else if(  file->is_version_less(**VERSION_TRIPLE, SUB_VERSION_TRIPLE**)  &&  file->is_saving()  ) {
+			// truncate double slopes to single slopes, better than nothing
+			sl = min( corner_sw(slope), 1 ) + min( corner_se(slope), 1 ) * 3 + min( corner_ne(slope), 1 ) * 9 + min( corner_nw(slope), 1 ) * 27;
+		}
+		*/
 		file->rdwr_byte(sl);
 		if(  file->is_loading()  ) {
 			slope = sl;
@@ -262,12 +268,23 @@
 	if(  file->is_loading()  ) {
 		if(  file->is_version_less(112, 7)  ) {
 			// convert slopes from old single height saved game
-			slope = (scorner_sw(slope) + scorner_se(slope) * 3 + scorner_ne(slope) * 9 + scorner_nw(slope) * 27) * env_t::pak_height_conversion_factor;
+			slope = (scorner_sw(slope) + scorner_se(slope) * slope_t::southeast + scorner_ne(slope) * slope_t::northeast + scorner_nw(slope) * slope_t::northwest) * env_t::pak_height_conversion_factor;
 		}
+		/* INSERT LOGIC TO LOAD FROM DOUBLE HEIGHTS */
+		else if(  file->is_version_less(121, 1 /*VERSION_TRIPLE, SUB_VERSION_TRIPLE*/)  ) {
+			// convert slopes from old single height saved game
+			slope = (dcorner_sw(slope) + dcorner_se(slope) * slope_t::southeast + dcorner_ne(slope) * slope_t::northeast + dcorner_nw(slope) * slope_t::northwest);
+		}
+
 		if(  !ground_desc_t::double_grounds  ) {
 			// truncate double slopes to single slopes
-			slope = min( corner_sw(slope), 1 ) + min( corner_se(slope), 1 ) * 3 + min( corner_ne(slope), 1 ) * 9 + min( corner_nw(slope), 1 ) * 27;
+			slope = min( corner_sw(slope), 1 ) + min( corner_se(slope), 1 ) * slope_t::southeast + min( corner_ne(slope), 1 ) * slope_t::northeast + min( corner_nw(slope), 1 ) * slope_t::northwest;
 		}
+		/* INSERT LOGIC TO TRUNCATE TRIPLE SLOPES */
+		else if(  !ground_desc_t::triple_grounds  ) {
+			// truncate triple slopes to double slopes
+			slope = min( corner_sw(slope), 2 ) + min( corner_se(slope), 2 ) * slope_t::southeast + min( corner_ne(slope), 2 ) * slope_t::northeast + min( corner_nw(slope), 2 ) * slope_t::northwest;
+		}
 	}
 
 	// restore grid
@@ -789,7 +806,7 @@
 			const uint8 back_height = min(corner_nw(slope_this),(i==0?corner_sw(slope_this):corner_ne(slope_this)));
 
 			const sint16 left_hgt=gr->get_disp_height()-back_height;
-			const sint8 slope=gr->get_disp_slope();
+			const slope_t::type slope=gr->get_disp_slope();
 
 			const uint8 corner_a = (i==0?corner_sw(slope_this):corner_nw(slope_this))-back_height;
 			const uint8 corner_b = (i==0?corner_nw(slope_this):corner_ne(slope_this))-back_height;
@@ -875,7 +892,7 @@
 		for(uint i=0; i<grund_t::BACK_CORNER_COUNT; i++) {
 			if(  const grund_t *gr=welt->lookup_kartenboden(k + testdir[i] - koord(step,step))  ) {
 				sint16 h = gr->get_disp_height()*scale_z_step;
-				sint8 s = gr->get_disp_slope();
+				slope_t::type s = gr->get_disp_slope();
 				// tile should hide anything in tunnel portal behind (tile not in direction of tunnel)
 				if (step == 0  &&  ((i&1)==0)  &&  s  &&  gr->ist_tunnel()) {
 					if ( ribi_t::reverse_single(ribi_type(s)) != ribi_type(testdir[i])) {
@@ -955,7 +972,7 @@
 			// choose foundation or natural slopes
 			const ground_desc_t *sl_draw = artificial ? ground_desc_t::fundament : ground_desc_t::slopes;
 
-			const sint8 disp_slope = get_disp_slope();
+			const slope_t::type disp_slope = get_disp_slope();
 			// first draw left, then back slopes
 			for(  size_t i=0;  i<grund_t::BACK_WALL_COUNT;  i++  ) {
 				const uint8 back_height = min(i==0?corner_sw(disp_slope):corner_ne(disp_slope),corner_nw(disp_slope));
@@ -970,7 +987,7 @@
 					grund_t *gr = welt->lookup_kartenboden( k + koord::nsew[(i-1)&3] );
 					if(  gr  ) {
 						// for left we test corners 2 and 3 (east), for back we use 1 and 2 (south)
-						const sint8 gr_slope = gr->get_disp_slope();
+						const slope_t::type gr_slope = gr->get_disp_slope();
 						uint8 corner_a = corner_se(gr_slope);
 						uint8 corner_b = i==0?corner_ne(gr_slope):corner_sw(gr_slope);
 
@@ -1045,7 +1062,7 @@
 
 					// get transition climate - look for each corner in turn
 					for(  int i = 0;  i < 4;  i++  ) {
-						sint8 corner_height = get_hoehe() + (slope_corner % 3);
+						sint8 corner_height = get_hoehe() + (slope_corner % slope_t::southeast);
 
 						climate transition_climate = climate0;
 						climate min_climate = arctic_climate;
@@ -1068,7 +1085,7 @@
 								uint8 overlay_corners = 1 << i;
 								slope_t::type slope_corner_se = slope_corner;
 								for(  int j = i + 1;  j < 4;  j++  ) {
-									slope_corner_se /= 3;
+									slope_corner_se /= slope_t::southeast;
 
 									// now we check to see if any of remaining corners have same climate transition (also using highest of course)
 									// if so we combine into this overlay layer
@@ -1075,7 +1092,7 @@
 									if(  (climate_corners >> j) & 1  ) {
 										climate compare = climate0;
 										for(  int k = 1;  k < 4;  k++  ) {
-											corner_height = get_hoehe() + (slope_corner_se % 3);
+											corner_height = get_hoehe() + (slope_corner_se % slope_t::southeast);
 											if(  corner_height == neighbour_height[(j * 2 + k) & 7][(j + k) & 3]) {
 												climate climatej = neighbour_climate[(j * 2 + k) & 7];
 												climatej > compare ? compare = climatej : 0;
@@ -1092,7 +1109,7 @@
 								display_alpha( ground_desc_t::get_climate_tile( transition_climate, slope ), ground_desc_t::get_alpha_tile( slope, overlay_corners ), ALPHA_GREEN | ALPHA_BLUE, xpos, ypos, 0, 0, true, dirty CLIP_NUM_PAR );
 							}
 						}
-						slope_corner /= 3;
+						slope_corner /= slope_t::southeast;
 					}
 					// finally overlay any water transition
 					if(  water_corners  ) {
@@ -1127,6 +1144,7 @@
 							}
 							break;
 						}
+						/* INSERT LOGIC HERE for 3rd height */
 					}
 				}
 
Index: boden/grund.h
===================================================================
--- boden/grund.h	(revision 9114)
+++ boden/grund.h	(working copy)
@@ -198,7 +198,7 @@
 	/**
 	 * Slope (now saved locally), because different grounds need different slopes
 	 */
-	uint8 slope;
+	slope_t::type slope;
 
 	/**
 	 * Image of the walls
@@ -229,7 +229,7 @@
 	static karte_ptr_t welt;
 
 	// calculates the slope image and sets the draw_as_obj flag correctly
-	void calc_back_image(const sint8 hgt,const sint8 slope_this);
+	void calc_back_image(const sint8 hgt,const slope_t::type slope_this);
 
 	// this is the real image calculation, called for the actual ground image
 	virtual void calc_image_internal(const bool calc_only_snowline_change) = 0;
Index: dataobj/ribi.cc
===================================================================
--- dataobj/ribi.cc	(revision 9114)
+++ dataobj/ribi.cc	(working copy)
@@ -83,88 +83,51 @@
 };
 
 
-static const ribi_t::ribi from_hang[81] = {
+static const ribi_t::ribi from_hang[256] = {
 	ribi_t::none, // ribi_t::none:flat
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::south,  // 4:north single height slope
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::south,  // 8:north doubles height slope
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::east,   // 12:west single height slope
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::east,   // 24:west doubles height slope
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::west,  // 28:east single height slope
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::north,  // 36:south single height slope
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::west,  // 56:east doubles height slope
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::north,  // 72:south doubles height slope
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none,
-	ribi_t::none  // 80:all of the above
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::south,  // 5:north single height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::south,  // 10:north doubles height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::south,  // 15:north triples height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::east,   // 20:west single height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::east,   // 40:west doubles height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::east,   // 60:west doubles height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::west,  // 65:east single height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::north,  // 80:south single height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::west,  // 130:east doubles height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::north,  // 160:south doubles height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::west,  // 195:east triples height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::north,  // 240:south doubles height slope
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none, ribi_t::none, ribi_t::none, ribi_t::none,
+	ribi_t::none  // 255:all of the above
 };
 
 
@@ -253,6 +216,266 @@
 };
 
 
+const int slope_t::eflags[256] = {
+	way_ns | way_ew,	// slope 0 # flat	straight ns|ew
+	0,	// slope 1 # sw1
+	doubles,	// slope 2 # sw2
+	triples,	// slope 3 # sw3
+	0,	// slope 4 # se1
+	way_ns | single,	// slope 5 # se1,sw1	straight ns
+	doubles,	// slope 6 # se1,sw2
+	triples,	// slope 7 # se1,sw3
+	doubles,	// slope 8 # se2
+	doubles,	// slope 9 # se2,sw1
+	way_ns | single | doubles,	// slope 10 # se2,sw2	straight ns2
+	triples,	// slope 11 # se2,sw3
+	doubles,	// slope 12 # se3
+	doubles,	// slope 13 # se3,sw1
+	doubles,	// slope 14 # se3,sw2	
+	way_ns | single | triples,	// slope 15 # se3,sw3	straight ns3
+	0,	// slope 16 # ne1
+	0,	// slope 17 # ne1,sw1
+	doubles,	// slope 18 # ne1,sw2
+	triples,	// slope 19 # ne1,sw3
+	way_ew | single,	// slope 20 # ne1,se1	straight ew
+	0,	// slope 21 # ne1,se1,sw1
+	doubles,	// slope 22 # ne1,se1,sw2
+	triples,	// slope 23 # ne1,se1,sw3
+	doubles,	// slope 24 # ne1,se2
+	doubles,	// slope 25 # ne1,se2,sw1
+	doubles,	// slope 26 # ne1,se2,sw2
+	triples,	// slope 27 # ne1,se2,sw3
+	doubles,	// slope 28 # ne1,se3
+	doubles,	// slope 29 # ne1,se3,sw1
+	doubles,	// slope 30 # ne1,se3,sw2
+	triples,	// slope 31 # ne1,se3,sw3
+	doubles,	// slope 32 # ne2
+	doubles,	// slope 33 # ne2,sw1
+	doubles,	// slope 34 # ne2,sw2
+	triples,	// slope 35 # ne2,sw3
+	doubles,	// slope 36 # ne2,se1
+	doubles,	// slope 37 # ne2,se1,sw1
+	doubles,	// slope 38 # ne2,se1,sw2
+	triples,	// slope 39 # ne2,se1,sw3
+	way_ew | single | doubles,	// slope 40 # ne2,se2	straight ew2
+	doubles,	// slope 41 # ne2,se2,sw1
+	doubles,	// slope 42 # ne2,se2,sw2
+	triples,	// slope 43 # ne2,se2,sw3
+	triples,	// slope 44 # ne2,se3
+	triples,	// slope 45 # ne2,se3,sw1
+	triples,	// slope 46 # ne2,se3,sw2
+	triples,	// slope 47 # ne2,se3,sw3
+	triples,	// slope 48 # ne3
+	triples,	// slope 49 # ne3,sw1
+	triples,	// slope 50 # ne3,sw2
+	triples,	// slope 51 # ne3,sw3
+	triples,	// slope 52 # ne3,se1
+	triples,	// slope 53 # ne3,se1,sw1
+	triples,	// slope 54 # ne3,se1,sw2
+	triples,	// slope 55 # ne3,se1,sw3
+	triples,	// slope 56 # ne3,se2
+	triples,	// slope 57 # ne3,se2,sw1
+	triples,	// slope 58 # ne3,se2,sw2
+	triples,	// slope 59 # ne3,se2,sw3
+	way_ew | single | triples,	// slope 60 # ne3,se3	straight ew3
+	triples,	// slope 61 # ne3,se3,sw1
+	triples,	// slope 62 # ne3,se3,sw2
+	triples,	// slope 63 # ne3,se3,sw3
+	0,	// slope 64 # nw1
+	way_ew | single,	// slope 65 # nw1,sw1	straight ew
+	doubles,	// slope 66 # nw1,sw2
+	triples,	// slope 67 # nw1,sw3
+	0,	// slope 68 # nw1,se1
+	0,	// slope 69 # nw1,se1,sw1
+	doubles,	// slope 70 # nw1,se1,sw2
+	triples,	// slope 71 # nw1,se1,sw3
+	0,	// slope 72 # nw1,se2
+	0,	// slope 73 # nw1,se2,sw1
+	doubles,	// slope 74 # nw1,se2,sw2
+	triples,	// slope 75 # nw1,se2,sw3
+	triples,	// slope 76 # nw1,se3
+	triples,	// slope 77 # nw1,se3,sw1
+	triples,	// slope 78 # nw1,se3,sw2
+	triples,	// slope 79 # nw1,se3,sw3
+	way_ns | single,	// slope 80 # nw1,ne1	straight ns
+	0,	// slope 81 # nw1,ne1,sw1
+	doubles,	// slope 82 # nw1,ne1,sw2
+	triples,	// slope 83 # nw1,ne1,sw3
+	0,	// slope 84 # nw1,ne1,se1
+	way_ns | way_ew | all_up,	// slope 85 # nw1,ne1,se1,sw1	TODO	0 up 1
+	doubles | all_up,	// slope 86 # nw1,ne1,se1,sw2	TODO	1 up 1
+	triples | all_up,	// slope 87 # nw1,ne1,se1,sw3	TODO	2 up 1
+	doubles,	// slope 88 # nw1,ne1,se2
+	doubles | all_up,	// slope 89 # nw1,ne1,se2,sw1	TODO	4 up 1
+	way_ns | single | doubles | all_up,	// slope 90 # nw1,ne1,se2,sw2	TODOns	5 up 1
+	triples | all_up,	// slope 91 # nw1,ne1,se2,sw3	TODOns	6 up 1
+	triples,	// slope 92 # nw1,ne1,se3
+	triples | all_up,	// slope 93 # nw1,ne1,se3,sw1	TODO	8 up 1
+	triples | all_up,	// slope 94 # nw1,ne1,se3,sw2	TODOns	9 up 1
+	way_ns | single | triples | all_up,	// slope 95 # nw1,ne1,se3,sw3	TODOns	10 up 1
+	doubles,	// slope 96 # nw1,ne2
+	doubles,	// slope 97 # nw1,ne2,sw1
+	doubles,	// slope 98 # nw1,ne2,sw2
+	triples,	// slope 99 # nw1,ne2,sw3
+	doubles,	// slope 100 # nw1,ne2,se1
+	doubles | all_up,	// slope 101 # nw1,ne2,se1,sw1	TODO	16 up 1
+	doubles | all_up,	// slope 102 # nw1,ne2,se1,sw2	TODO	17 up 1
+	triples | all_up,	// slope 103 # nw1,ne2,se1,sw3	TODO	18 up 1
+	doubles,	// slope 104 # nw1,ne2,se2
+	way_ew | single | doubles | all_up,	// slope 105 # nw1,ne2,se2,sw1	TODOew	20 up 1
+	doubles | all_up,	// slope 106 # nw1,ne2,se2,sw2	TODO	21 up 1
+	triples | all_up,	// slope 107 # nw1,ne2,se2,sw3	TODO	22 up 1
+	triples,	// slope 108 # nw1,ne2,se3
+	triples | all_up,	// slope 109 # nw1,ne2,se3,sw1	TODOew	24 up 1
+	triples | all_up,	// slope 110 # nw1,ne2,se3,sw2	TODO	25 up 1
+	triples | all_up,	// slope 111 # nw1,ne2,se3,sw3	TODO	26 up 1
+	triples,	// slope 112 # nw1,ne3
+	triples,	// slope 113 # nw1,ne3,sw1
+	triples,	// slope 114 # nw1,ne3,sw2
+	triples,	// slope 115 # nw1,ne3,sw3
+	triples,	// slope 116 # nw1,ne3,se1
+	triples | all_up,	// slope 117 # nw1,ne3,se1,sw1	TODO	32 up 1
+	triples | all_up,	// slope 118 # nw1,ne3,se1,sw2	TODO	33 up 1
+	triples | all_up,	// slope 119 # nw1,ne3,se1,sw3	TODO	34 up 1
+	triples,	// slope 120 # nw1,ne3,se2
+	triples | all_up,	// slope 121 # nw1,ne3,se2,sw1	TODOew	36 up 1
+	triples | all_up,	// slope 122 # nw1,ne3,se2,sw2	TODO	37 up 1
+	triples | all_up,	// slope 123 # nw1,ne3,se2,sw3	TODO	38 up 1
+	triples,	// slope 124 # nw1,ne3,se3
+	way_ew | single | triples | all_up,	// slope 125 # nw1,ne3,se3,sw1	TODOew	40 up 1
+	triples | all_up,	// slope 126 # nw1,ne3,se3,sw2	TODO	41 up 1
+	triples | all_up,	// slope 127 # nw1,ne3,se3,sw3	TODO	42 up 1
+	doubles,	// slope 128 # nw2
+	doubles,	// slope 129 # nw2,sw1
+	way_ew | single | doubles,	// slope 130 # nw2,sw2	straight ew2
+	triples,	// slope 131 # nw2,sw3
+	doubles,	// slope 132 # nw2,se1
+	doubles,	// slope 133 # nw2,se1,sw1
+	doubles,	// slope 134 # nw2,se1,sw2
+	triples,	// slope 135 # nw2,se1,sw3
+	doubles,	// slope 136 # nw2,se2
+	doubles,	// slope 137 # nw2,se2,sw1
+	doubles,	// slope 138 # nw2,se2,sw2
+	triples,	// slope 139 # nw2,se2,sw3
+	triples,	// slope 140 # nw2,se3
+	triples,	// slope 141 # nw2,se3,sw1
+	triples,	// slope 142 # nw2,se3,sw2
+	triples,	// slope 143 # nw2,se3,sw3
+	doubles,	// slope 144 # nw2,ne1
+	doubles,	// slope 145 # nw2,ne1,sw1
+	doubles,	// slope 146 # nw2,ne1,sw2
+	triples,	// slope 147 # nw2,ne1,sw3
+	doubles,	// slope 148 # nw2,ne1,se1
+	doubles | all_up,	// slope 149 # nw2,ne1,se1,sw1	TODO	64 up 1
+	way_ew | single | doubles | all_up,	// slope 150 # nw2,ne1,se1,sw2	TODOew	65 up 1
+	triples | all_up,	// slope 151 # nw2,ne1,se1,sw3	TODOew	66 up 1
+	doubles,	// slope 152 # nw2,ne1,se2
+	doubles | all_up,	// slope 153 # nw2,ne1,se2,sw1	TODO	68 up 1
+	doubles | all_up,	// slope 154 # nw2,ne1,se2,sw2	TODO	69 up 1
+	triples | all_up,	// slope 155 # nw2,ne1,se2,sw3	TODO	70 up 1
+	triples,	// slope 156 # nw2,ne1,se3
+	triples | all_up,	// slope 157 # nw2,ne1,se3,sw1	TODO	72 up 1
+	triples | all_up,	// slope 158 # nw2,ne1,se3,sw2	TODO	73 up 1
+	triples | all_up,	// slope 159 # nw2,ne1,se3,sw3	TODO	74 up 1
+	way_ns | single | doubles,	// slope 160 # nw2,ne2	straight ns2
+	doubles,	// slope 161 # nw2,ne2,sw1
+	doubles,	// slope 162 # nw2,ne2,sw2
+	triples,	// slope 163 # nw2,ne2,sw3
+	doubles,	// slope 164 # nw2,ne2,se1
+	way_ns | single | doubles | all_up,	// slope 165 # nw2,ne2,se1,sw1	TODOns	80 up 1
+	doubles | all_up,	// slope 166 # nw2,ne2,se1,sw2	TODO	81 up 1
+	triples | all_up,	// slope 167 # nw2,ne2,se1,sw3	TODO	82 up 1
+	doubles,	// slope 168 # nw2,ne2,se2
+	doubles | all_up,	// slope 169 # nw2,ne2,se2,sw1	TODO	84 up 1
+	way_ns | way_ew | doubles | all_up,	// slope 170 # nw2,ne2,se2,sw2	TODO	[[85 up 1 =]] 0 up 2
+	triples | all_up,	// slope 171 # nw2,ne2,se2,sw3	TODO	[[86 up 2 =]] 1 up 2
+	triples,	// slope 172 # nw2,ne2,se3
+	triples | all_up,	// slope 173 # nw2,ne2,se3,sw1	TODO	88 up 1
+	triples | all_up,	// slope 174 # nw2,ne2,se3,sw2	TODO	[[89 up 1 =]] 4 up 2
+	way_ns | triples | all_up,	// slope 175 # nw2,ne2,se3,sw3	TODO	[[90 up 1 =]] 5 up 2
+	triples,	// slope 176 # nw2,ne3
+	triples,	// slope 177 # nw2,ne3,sw1
+	triples,	// slope 178 # nw2,ne3,sw2
+	triples,	// slope 179 # nw2,ne3,sw3
+	triples,	// slope 180 # nw2,ne3,se1
+	triples | all_up,	// slope 181 # nw2,ne3,se1,sw1	TODOns	96 up 1
+	triples | all_up,	// slope 182 # nw2,ne3,se1,sw2	TODO	97 up 1
+	triples | all_up,	// slope 183 # nw2,ne3,se1,sw3	TODO	98 up 1
+	triples,	// slope 184 # nw2,ne3,se2
+	triples | all_up,	// slope 185 # nw2,ne3,se2,sw1	TODO	100 up 1
+	triples | all_up,	// slope 186 # nw2,ne3,se2,sw2	TODO	101 up 1
+	triples | all_up,	// slope 187 # nw2,ne3,se2,sw3	TODO	102 up 1
+	triples,	// slope 188 # nw2,ne3,se3
+	triples | all_up,	// slope 189 # nw2,ne3,se3,sw1	TODO	104 up 1
+	way_ew | triples | all_up,	// slope 190 # nw2,ne3,se3,sw2	TODO	105 up 1 [[=20 up 2]]
+	triples | all_up,	// slope 191 # nw2,ne3,se3,sw3	TODO	106 up 1 [[=21 up 2]
+	triples, // slope 192 # nw3,ne0,se0,sw0
+	triples, // slope 193 # nw3,ne0,se0,sw1
+	triples, // slope 194 # nw3,ne0,se0,sw2
+	way_ew | single | triples, // slope 195 # nw3,ne0,se0,sw3
+	triples, // slope 196 # nw3,ne0,se1,sw0
+	triples, // slope 197 # nw3,ne0,se1,sw1
+	triples, // slope 198 # nw3,ne0,se1,sw2
+	triples, // slope 199 # nw3,ne0,se1,sw3
+	triples, // slope 200 # nw3,ne0,se2,sw0
+	triples, // slope 201 # nw3,ne0,se2,sw1
+	triples, // slope 202 # nw3,ne0,se2,sw2
+	triples, // slope 203 # nw3,ne0,se2,sw3
+	triples, // slope 204 # nw3,ne0,se3,sw0
+	triples, // slope 205 # nw3,ne0,se3,sw1
+	triples, // slope 206 # nw3,ne0,se3,sw2
+	triples, // slope 207 # nw3,ne0,se3,sw3
+	triples, // slope 208 # nw3,ne1,se0,sw0
+	triples, // slope 209 # nw3,ne1,se0,sw1
+	triples, // slope 210 # nw3,ne1,se0,sw2
+	triples, // slope 211 # nw3,ne1,se0,sw3
+	triples, // slope 212 # nw3,ne1,se1,sw0
+	triples | all_up, // slope 213 # nw3,ne1,se1,sw1
+	triples | all_up, // slope 214 # nw3,ne1,se1,sw2
+	way_ew | single | triples | all_up, // slope 215 # nw3,ne1,se1,sw3
+	triples, // slope 216 # nw3,ne1,se2,sw0
+	triples | all_up, // slope 217 # nw3,ne1,se2,sw1
+	triples | all_up, // slope 218 # nw3,ne1,se2,sw2
+	triples | all_up, // slope 219 # nw3,ne1,se2,sw3
+	triples, // slope 220 # nw3,ne1,se3,sw0
+	triples | all_up, // slope 221 # nw3,ne1,se3,sw1
+	triples | all_up, // slope 222 # nw3,ne1,se3,sw2
+	triples | all_up, // slope 223 # nw3,ne1,se3,sw3
+	triples, // slope 224 # nw3,ne2,se0,sw0
+	triples | all_up, // slope 225 # nw3,ne2,se0,sw1
+	triples | all_up, // slope 226 # nw3,ne2,se0,sw2
+	triples | all_up, // slope 227 # nw3,ne2,se0,sw3
+	triples, // slope 228 # nw3,ne2,se1,sw0
+	triples | all_up, // slope 229 # nw3,ne2,se1,sw1
+	triples | all_up, // slope 230 # nw3,ne2,se1,sw2
+	triples | all_up, // slope 231 # nw3,ne2,se1,sw3
+	triples, // slope 232 # nw3,ne3,se2,sw0
+	triples | all_up, // slope 233 # nw3,ne2,se2,sw1
+	triples | all_up, // slope 234 # nw3,ne2,se2,sw2
+	way_ew | single | triples | all_up, // slope 235 # nw3,ne2,se2,sw3
+	triples, // slope 236 # nw3,ne3,se3,sw0
+	triples | all_up, // slope 237 # nw3,ne2,se3,sw1
+	triples | all_up, // slope 238 # nw3,ne2,se3,sw2
+	triples | all_up, // slope 239 # nw3,ne2,se3,sw3
+	way_ns | single | triples, // slope 240 # nw3,ne3,se0,sw0
+	triples | all_up, // slope 241 # nw3,ne3,se0,sw1
+	triples | all_up, // slope 242 # nw3,ne3,se0,sw2
+	triples | all_up, // slope 243 # nw3,ne3,se0,sw3
+	triples, // slope 244 # nw3,ne3,se1,sw0
+	way_ns | single | triples | all_up, // slope 245 # nw3,ne3,se1,sw1
+	triples | all_up, // slope 246 # nw3,ne3,se1,sw2
+	triples | all_up, // slope 247 # nw3,ne3,se1,sw3
+	triples, // slope 248 # nw3,ne3,se2,sw0
+	triples | all_up, // slope 249 # nw3,ne3,se2,sw1
+	way_ns | single | triples | all_up, // slope 250 # nw3,ne3,se2,sw2
+	triples | all_up, // slope 251 # nw3,ne3,se2,sw3
+	triples, // slope 252 # nw3,ne3,se3,sw0
+	triples | all_up, // slope 253 # nw3,ne3,se3,sw1
+	triples | all_up, // slope 254 # nw3,ne3,se3,sw2
+	way_ns | way_ew | triples | all_up, // slope 255 # nw3,ne3,se3,sw3
+};
+
+
 const slope_t::type slope_from_ribi[16] = {
 	0,
 	slope_t::south,
@@ -362,6 +585,9 @@
 	else if (2*from_slope == slope) {
 		return 2;
 	}
+	else if (/* insert logic here PAK_3_HEIGHTS==TRUE && */ 3*from_slope == slope) {
+		return 3;
+	}
 	return 0;
 }
 
Index: dataobj/ribi.h
===================================================================
--- dataobj/ribi.h	(revision 9114)
+++ dataobj/ribi.h	(working copy)
@@ -21,44 +21,67 @@
 
 	/// Static lookup table
 	static const int flags[81];
+	static const int eflags[256];
 
 	/// Named constants for the flags table
 	enum {
 		doubles = 1,   ///< two-height difference slopes
-		way_ns  = 2,   ///< way possible in north-south direction
-		way_ew  = 4,   ///< way possible in east-west direction
-		single  = 8,   ///< way possible
-		all_up  = 16,  ///< all corners raised
+		triples = 2,   ///< two-height difference slopes - note: doubles|triples invalid
+		height = 3,   ///< two-height difference slopes - combine double and triple to give height
+		way_ns  = 4,   ///< way possible in north-south direction
+		way_ew  = 8,   ///< way possible in east-west direction
+		single  = 16,   ///< way possible
+		all_up  = 32,  ///< all corners raised
 	};
 
 public:
 
-	typedef sint8 type;
+	typedef uint8 type;
 
 	/*
-	 * Macros to access the height of the 4 corners:
+	 * Macros to access the height of the 4 corners - compatibility for 0,1,2:
 	 * Each corner has height 0,1,2.
 	 * Calculation has to be done modulo 3 (% 3).
 	 */
-#define corner_sw(i) (i%3)      // sw corner
-#define corner_se(i) ((i/3)%3)  // se corner
-#define corner_ne(i) ((i/9)%3)  // ne corner
-#define corner_nw(i) (i/27)     // nw corner
+#define dcorner_sw(i) (i%3)    	// sw corner
+#define dcorner_se(i) ((i/3)%3)	// se corner
+#define dcorner_ne(i) ((i/9)%3)	// ne corner
+#define dcorner_nw(i) (i/27)   	// nw corner
 
+	/*
+	 * Macros to access the height of the 4 corners:
+	 * Each corner has height 0,1,2,3.
+	 * Calculation has to be done modulo 4 (% 4).
+	 */
+#define corner_sw(i) (i%4)    	// sw corner
+#define corner_se(i) ((i/4)%4)	// se corner
+#define corner_ne(i) ((i/16)%4)	// ne corner
+#define corner_nw(i) (i/64)   	// nw corner
+
 	/**
 	 * Named constants for special cases.
 	 */
 	enum _type {
 		flat=0,
-		north = 3+1,    ///< North slope
-		west = 9+3,     ///< West slope
-		east = 27+1,    ///< East slope
-		south = 27+9,   ///< South slope
-		northwest = 27, ///< NW corner
-		northeast = 9,  ///< NE corner
-		southeast = 3,  ///< SE corner
+		north = 4+1,    ///< North slope
+		west = 16+4,     ///< West slope
+		east = 64+1,    ///< East slope
+		south = 64+16,   ///< South slope
+		northwest = 64, ///< NW corner
+		northeast = 16,  ///< NE corner
+		southeast = 4,  ///< SE corner
 		southwest = 1,  ///< SW corner
-		raised = 80,    ///< special meaning: used as slope of bridgeheads and in terraforming tools
+		raised = 255,    ///< special meaning: used as slope of bridgeheads and in terraforming tools
+
+		compat_north = 3+1,    ///< North slope
+		compat_west = 9+3,     ///< West slope
+		compat_east = 27+1,    ///< East slope
+		compat_south = 27+9,   ///< South slope
+		compat_northwest = 27, ///< NW corner
+		compat_northeast = 9,  ///< NE corner
+		compat_southeast = 3,  ///< SE corner
+		compat_southwest = 1,  ///< SW corner
+		compat_raised = 80,    ///< special meaning: used as slope of bridgeheads and in terraforming tools
 	};
 
 
@@ -67,20 +90,20 @@
 	/// Rotate.
 	static type rotate90(type x) { return ( ( (x % 3) * 27 ) + ( ( x - (x % 3) ) / 3 ) ); }
 	/// Returns true if @p x has all corners raised.
-	static bool is_all_up(type x) { return (flags[x] & all_up)>0; }
+	static bool is_all_up(type x) { return (eflags[x] & all_up)>0; }
 	/// Returns maximal height difference between the corners of this slope.
-	static uint8 max_diff(type x) { return (x!=0)+(flags[x]&doubles); }
+	static uint8 max_diff(type x) { return (x!=0)+(eflags[x]&height); }
 	/// Computes minimum height differnce between corners of  @p high and @p low.
 	static sint8 min_diff(type high, type low) { return min( min( corner_sw(high) - corner_sw(low), corner_se(high)-corner_se(low) ), min( corner_ne(high) - corner_ne(low), corner_nw(high) - corner_nw(low) ) ); }
 
 	/// Returns if slope prefers certain way directions (either n/s or e/w).
-	static bool is_single(type x) { return (flags[x] & single) != 0; }
+	static bool is_single(type x) { return (eflags[x] & single) != 0; }
 	/// Returns if way can be build on this slope.
-	static bool is_way(type x)  { return (flags[x] & (way_ns | way_ew)) != 0; }
+	static bool is_way(type x)  { return (eflags[x] & (way_ns | way_ew)) != 0; }
 	/// Returns if way in n/s direction can be build on this slope.
-	static bool is_way_ns(type x)  { return (flags[x] & way_ns) != 0; }
+	static bool is_way_ns(type x)  { return (eflags[x] & way_ns) != 0; }
 	/// Returns if way in e/w direction can be build on this slope.
-	static bool is_way_ew(type x)  { return (flags[x] & way_ew) != 0; }
+	static bool is_way_ew(type x)  { return (eflags[x] & way_ew) != 0; }
 };
 
 
@@ -101,7 +124,7 @@
 	 * Macros to access the height of the 4 corners for single slope:
 	 * One bit per corner
 	 */
-	typedef sint8 type;
+	typedef uint8 type;
 
 	#define scorner_sw(i) (i%2)     // sw corner
 	#define scorner_se(i) ((i/2)%2) // se corner
@@ -157,7 +180,7 @@
 		southeastwest = 14,
 		all = 15
 	};
-	typedef uint8 ribi;
+	typedef sint8 ribi;
 
 	/**
 	 * Named constants to translate direction to image number for vehicles, signs.
Index: descriptor/ground_desc.cc
===================================================================
--- descriptor/ground_desc.cc	(revision 9114)
+++ descriptor/ground_desc.cc	(working copy)
@@ -13,10 +13,10 @@
 #include "ground_desc.h"
 #include "../dataobj/environment.h"
 
-//const int totalslopes_single = 16;
-const int totalslopes = 81;
+const int totalslopes_single = 16;
+const int totalslopes_double = 81;
+const int totalslopes = 256;
 
-
 /****************************************************************************************************
 * some functions for manipulations/blending images
 * maybe they should be put in their own module, even though they are only used here ...
@@ -304,21 +304,11 @@
 karte_t *ground_desc_t::world = NULL;
 
 
-/* convert double to single slopes
+/* convert double/triple slopes to single slopes (INSERT initialise algorithmically)
  */
-const uint8 ground_desc_t::slopetable[80] =
-{
-	0,    1,    0xFF, 2,    3,    0xFF, 0xFF, 0xFF, 0xFF, 4,
-	5,    0xFF, 6,    7,    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 8,    9,    0xFF,
-	10,   11,   0xFF, 0xFF, 0xFF, 0xFF, 12,   13,   0xFF, 14,
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-};
+uint8 ground_desc_t::slopetable[255];
+uint8 ground_desc_t::doubleslopetable[255];
 
-
 // since we only use valid slope (to gain some more image slots) we use this lookup table
 // 255 slopes are invalid
 /* for double slope it should look like this, and for single slope like above
@@ -328,7 +318,7 @@
 	44, 255, 255, 45, 255, 255, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
 	56, 57, 58, 255, 255, 59, 255, 255, 60, 61, 62, 63, 255, 255, 64, 255, 255
 */
-uint16 doubleslope_to_imgnr[81];
+uint16 doubleslope_to_imgnr[256];
 
 
 // how many animation stages we got for waves
@@ -338,6 +328,9 @@
 // are double_grounds available in this pakset ?
 bool ground_desc_t::double_grounds = true;
 
+// are triple_grounds available in this pakset ?
+bool ground_desc_t::triple_grounds = true;
+
 static const ground_desc_t* boden_texture            = NULL;
 static const ground_desc_t* light_map                = NULL;
 static const ground_desc_t* transition_water_texture = NULL;
@@ -461,12 +454,22 @@
 
 	bool full_climate = true;
 	// check if there are double slopes available
-	for(  int imgindex = 16;  imgindex < totalslopes;  imgindex++  ) {
+	for(  int imgindex = totalslopes_single;  imgindex < totalslopes_double;  imgindex++  ) {
 		if(  light_map->get_image_ptr(imgindex) == NULL  ) {
 			double_grounds = false;
 			break;
 		}
 	}
+	if(  double_grounds  ) {
+	// check if there are triple slopes available
+		for(  int imgindex = totalslopes_double;  imgindex < totalslopes;  imgindex++  ) {
+			if(  light_map->get_image_ptr(imgindex) == NULL  ) {
+				triple_grounds = false;
+				break;
+			}
+		}
+	}
+
 	for(  int imgindex = 4;  imgindex < 15;  imgindex++  ) {
 		if(  transition_slope_texture->get_image_ptr(imgindex) == NULL   ||
 			(imgindex<=11  &&  transition_water_texture->get_image_ptr(imgindex) == NULL) ) {
@@ -482,11 +485,11 @@
 	for(  int slope = 1, slopeimgnr=1;  slope < totalslopes;  slope++  ) {
 		all_rotations_beach[slope] = NULL;
 		all_rotations_slope[slope] = NULL;
-		doubleslope_to_imgnr[slope] = 255;
+		doubleslope_to_imgnr[slope] = 256;
 
-		if(  slope != 80  &&  (slope_t::is_all_up(slope)  ||  (!double_grounds  &&  slope_t::max_diff(slope)>1)  )  ) {
+		if(  slope != totalslopes-1  &&  (slope_t::is_all_up(slope) || (!double_grounds  &&  slope_t::max_diff(slope)>1) || (!triple_grounds  &&  slope_t::max_diff(slope)>2))  ) {
 			// no need to initialize unneeded slopes
-			// slope 80 is needed below
+			// slope totalslopes-1 is needed below
 			continue;
 		}
 
@@ -803,7 +806,7 @@
 							all_rotations_slope[slope] = transition_slope_texture->get_image_ptr(11)->copy_rotate(0);
 							break;
 						}
-						case slope_t::southwest * 2 + slope_t::northeast * 2 + slope_t::southeast * 2 + slope_t::northwest * 2: {
+						case slope_t::southwest * 3 + slope_t::northeast * 3 + slope_t::southeast * 3 + slope_t::northwest * 3: {
 							all_rotations_slope[slope] = transition_slope_texture->get_image_ptr(14)->copy_rotate(0);
 							all_rotations_beach[slope] = transition_water_texture->get_image_ptr(11)->copy_rotate(0);
 							break;
@@ -812,7 +815,7 @@
 				}
 				else {
 					all_rotations_slope[slope] = NULL;
-					if (slope == slope_t::southwest * 2 + slope_t::northeast * 2 + slope_t::southeast * 2 + slope_t::northwest * 2) {
+					if (slope == slope_t::southwest * 3 + slope_t::northeast * 3 + slope_t::southeast * 3 + slope_t::northwest * 3) {
 						all_rotations_slope[slope] = transition_slope_texture->get_image_ptr(0)->copy_rotate(0);
 						all_rotations_beach[slope] = transition_water_texture->get_image_ptr(0)->copy_rotate(0);
 					}
@@ -822,6 +825,22 @@
 		}
 	}
 
+	// calculate slope tables
+	for(  int dslope = 0; dslope <totalslopes - 1; dslope++ ) {
+		if(  slope_t::max_diff(dslope)<2  ) {
+			slopetable[dslope] = corner_sw(dslope) + 2*corner_se(dslope) + 4*corner_ne(dslope) + 8*corner_nw(dslope);
+		}
+		else {
+			slopetable[dslope] = 255;
+		}
+		if(  slope_t::max_diff(dslope)<3  ) {
+			doubleslopetable[dslope] = corner_sw(dslope) + 3*corner_se(dslope) + 9*corner_ne(dslope) + 27*corner_nw(dslope);
+		}
+		else {
+			doubleslopetable[dslope] = 255;
+		}
+	}
+
 	// from here on the images are generated by us => deletion also by us then
 	image_offset = get_image_count();
 	DBG_MESSAGE("ground_desc_t::init_ground_textures()","image_offset=%d", image_offset );
@@ -835,8 +854,8 @@
 	}
 	for(  int dslope = 0;  dslope < totalslopes - 1;  dslope++  ) {
 		for(uint16 stage = 0; stage < water_animation_stages; stage++) {
-			if(  doubleslope_to_imgnr[dslope] != 255  ) {
-				int slope = double_grounds ? dslope : slopetable[dslope];
+			if(  doubleslope_to_imgnr[dslope] != 256  ) {
+				int slope = triple_grounds ? dslope : (double_grounds ? doubleslopetable[dslope] : slopetable[dslope]);
 				final_tile = create_textured_tile( light_map->get_image_ptr( slope ), water_stage_texture[stage], true);
 				ground_image_list.append( final_tile );
 			}
@@ -852,8 +871,8 @@
 		// normal tile (no transition, not snow)
 		climate_image[i] = get_image_count();
 		for(  int dslope = 0;  dslope < totalslopes - 1;  dslope++  ) {
-			if(  doubleslope_to_imgnr[dslope] != 255  ) {
-				int slope = double_grounds ? dslope : slopetable[dslope];
+			if(  doubleslope_to_imgnr[dslope] != 256  ) {
+				int slope = triple_grounds ? dslope : (double_grounds ? doubleslopetable[dslope] : slopetable[dslope]);
 				final_tile = create_textured_tile( light_map->get_image_ptr( slope ), boden_texture->get_image_ptr( i+1 ) );
 				ground_image_list.append( final_tile );
 			}
@@ -862,8 +881,8 @@
 	// finally full snow
 	climate_image[number_of_climates] = final_tile->get_id() + 1;
 	for(  int dslope = 0;  dslope < totalslopes - 1;  dslope++  ) {
-		if(  doubleslope_to_imgnr[dslope] != 255  ) {
-			int slope = double_grounds ? dslope : slopetable[dslope];
+		if(  doubleslope_to_imgnr[dslope] != 256  ) {
+			int slope = triple_grounds ? dslope : (double_grounds ? doubleslopetable[dslope] : slopetable[dslope]);
 			final_tile = create_textured_tile( light_map->get_image_ptr( slope ), boden_texture->get_image_ptr( arctic_climate ) );
 			ground_image_list.append( final_tile );
 		}
@@ -871,8 +890,8 @@
 
 	// alpha slopes for snowline
 	for(  int dslope = 1;  dslope < totalslopes - 1;  dslope++  ) {
-		if(  doubleslope_to_imgnr[dslope] != 255  ) {
-			int slope = double_grounds ? dslope : slopetable[dslope];
+		if(  doubleslope_to_imgnr[dslope] != 256  ) {
+			int slope = triple_grounds ? dslope : (double_grounds ? doubleslopetable[dslope] : slopetable[dslope]);
 			final_tile = create_alpha_tile( light_map->get_image_ptr( slope ), dslope, all_rotations_slope[dslope] );
 			alpha_image[dslope] = final_tile->get_id();
 		}
@@ -884,17 +903,18 @@
 	// alpha transitions for climates
 	for(  int dslope = 0;  dslope < totalslopes - 1;  dslope++  ) {
 		for(  int corners = 1;  corners < 16;  corners++  ) {
-			if(  doubleslope_to_imgnr[dslope] != 255  ) {
+			if(  doubleslope_to_imgnr[dslope] != 256  ) {
 				// slope of tile
-				int slope = double_grounds ? dslope : slopetable[dslope];
+				int slope = triple_grounds ? dslope : (double_grounds ? doubleslopetable[dslope] : slopetable[dslope]);
+
 				// corners with transition
-				uint8 double_corners = corners == 15 ? 80 : scorner_sw(corners) + 3 * scorner_se(corners) + 9 * scorner_ne(corners) + 27 * scorner_nw(corners);
+				uint8 double_corners = corners == 15 ? 255 : scorner_sw(corners) + slope_t::southeast * scorner_se(corners) + slope_t::northeast * scorner_ne(corners) + slope_t::northwest * scorner_nw(corners);
 
 				// create alpha image
 				final_tile = create_alpha_tile( light_map->get_image_ptr( slope ), dslope, all_rotations_slope[double_corners] );
 				alpha_corners_image[dslope * 15 + corners - 1] = final_tile->get_id();
 
-				double_corners = corners == 15 ? 80 : (1 - scorner_sw(corners)) + 3 * (1 - scorner_se(corners)) + 9 * (1 - scorner_ne(corners)) + 27 * (1 - scorner_nw(corners));
+				double_corners = corners == 15 ? 255 : (1 - scorner_sw(corners)) + slope_t::southeast * (1 - scorner_se(corners)) + slope_t::northeast * (1 - scorner_ne(corners)) + slope_t::northwest * (1 - scorner_nw(corners));
 				if(  all_rotations_beach[double_corners]  ) {
 					final_tile = create_alpha_tile( light_map->get_image_ptr( slope ), dslope, all_rotations_beach[double_corners] );
 					alpha_water_image[dslope * 15 + corners - 1] = final_tile->get_id();
Index: descriptor/ground_desc.h
===================================================================
--- descriptor/ground_desc.h	(revision 9114)
+++ descriptor/ground_desc.h	(working copy)
@@ -47,8 +47,10 @@
 	static char const* get_climate_name_from_bit(climate n);
 
 	static bool double_grounds;
+	static bool triple_grounds;
 
-	static const uint8 slopetable[80];
+	static uint8 slopetable[255];
+	static uint8 doubleslopetable[255];
 
 	// returns the pointer to an image structure
 	const image_t *get_image_ptr(uint16 typ, uint16 stage=0) const
@@ -90,18 +92,21 @@
 
 	static image_id get_marker_image(slope_t::type slope_in, bool background)
 	{
-		uint8 slope = double_grounds ? slope_in : slopetable[slope_in];
-		uint8 index = background ? (double_grounds ? (slope % 3) + 3 * ((uint8)(slope / 9)) + 27
-		                                           : ((slope & 1) + ((slope >> 1) & 6) + 8))
-		                         : (double_grounds ?  slope % 27
-		                                           : (slope & 7 ));
+		uint8 slope = triple_grounds ? slope_in : (double_grounds ? doubleslopetable[slope_in] : slopetable[slope_in]);
+		uint8 index = background ? ( triple_grounds ? ( (slope & 3) + ((slope >> 2) & 60) + 64 )
+						: (double_grounds ? (slope % 3) + 3 * ((uint8)(slope / 9)) + 27
+		                                	           : ((slope & 1) + ((slope >> 1) & 6) + 8) ))
+		                         : ( triple_grounds ? ( slope & 63 )
+						: (double_grounds ?  slope % 27
+		                                	           : (slope & 7 )) );
 		return marker->get_image(index);
 	}
 
 	static image_id get_border_image(slope_t::type slope_in)
 	{
-		uint8 slope = double_grounds ? slope_in : slopetable[slope_in];
-		uint8 index = double_grounds ? (slope % 3) + 3 * ((uint8)(slope / 9)) : (slope & 1) + ((slope >> 1) & 6);
+		uint8 slope = triple_grounds ? slope_in : (double_grounds ? doubleslopetable[slope_in] : slopetable[slope_in]);
+		uint8 index = triple_grounds? ((slope & 3) + ((slope >> 2) & 60))
+						: ( double_grounds ? (slope % 3) + 3 * ((uint8)(slope / 9)) : (slope & 1) + ((slope >> 1) & 6 ) );
 		return borders->get_image(index);
 	}
 };
Index: descriptor/way_desc.h
===================================================================
--- descriptor/way_desc.h	(revision 9114)
+++ descriptor/way_desc.h	(working copy)
@@ -136,28 +136,28 @@
 		const uint16 n = image_list_base_index(season, front) + 1;
 		uint16 nr;
 		switch(slope) {
-			case 4:
+			case slope_t::north:
 				nr = 0;
 				break;
-			case 12:
+			case slope_t::west:
 				nr = 1;
 				break;
-			case 28:
+			case slope_t::east:
 				nr = 2;
 				break;
-			case 36:
+			case slope_t::south:
 				nr = 3;
 				break;
-			case 8:
+			case slope_t::north*2:
 				nr = 4;
 				break;
-			case 24:
+			case slope_t::west*2:
 				nr = 5;
 				break;
-			case 56:
+			case slope_t::east*2:
 				nr = 6;
 				break;
-			case 72:
+			case slope_t::south*2:
 				nr = 7;
 				break;
 			default:
Index: descriptor/writer/ground_writer.cc
===================================================================
--- descriptor/writer/ground_writer.cc	(revision 9114)
+++ descriptor/writer/ground_writer.cc	(working copy)
@@ -20,7 +20,7 @@
 
 	slist_tpl<slist_tpl<std::string> > keys;
 	// summer images
-	for (int slope = 0; slope < 128; slope++) {
+	for (int slope = 0; slope < 256; slope++) {
 		keys.append();
 
 		for (int phase = 0; ; phase++) {
Index: simworld.cc
===================================================================
--- simworld.cc	(revision 9114)
+++ simworld.cc	(working copy)
@@ -368,7 +368,7 @@
 				const sint8 disp_hn_ne = max( height + corner_ne(slope), water_hgt );
 				const sint8 disp_hn_nw = max( height + corner_nw(slope), water_hgt );
 				height = water_hgt;
-				slope = (disp_hn_sw - height) + ((disp_hn_se - height) * 3) + ((disp_hn_ne - height) * 9) + ((disp_hn_nw - height) * 27);
+				slope = (disp_hn_sw - height) + ((disp_hn_se - height) * slope_t::southeast) + ((disp_hn_ne - height) * slope_t::northeast) + ((disp_hn_nw - height) * slope_t::northwest);
 			}
 
 			gr->set_pos( koord3d( k, height) );
@@ -2323,7 +2323,7 @@
 	const sint8 hneu = min( min( hn_sw, hn_se ), min( hn_ne, hn_nw ) );
 	const sint8 hmaxneu = max( max( hn_sw, hn_se ), max( hn_ne, hn_nw ) );
 
-	const uint8 max_hdiff = ground_desc_t::double_grounds ? 2 : 1;
+	const uint8 max_hdiff = ground_desc_t::triple_grounds ? 3 : (ground_desc_t::double_grounds ?  2 : 1);
 
 	bool ok = (hmaxneu - hneu <= max_hdiff); // may fail on water tiles since lookup_hgt might be modified from previous raise_to calls
 	if(  !ok  &&  !gr->is_water()  ) {
@@ -2397,13 +2397,13 @@
 	const sint8 hneu = min( min( hn_sw, hn_se ), min( hn_ne, hn_nw ) );
 	const sint8 hmaxneu = max( max( hn_sw, hn_se ), max( hn_ne, hn_nw ) );
 
-	const uint8 max_hdiff = ground_desc_t::double_grounds ? 2 : 1;
+	const uint8 max_hdiff = ground_desc_t::triple_grounds ? 3 : (ground_desc_t::double_grounds ?  2 : 1);
 	const sint8 disp_hneu = max( hneu, water_hgt );
 	const sint8 disp_hn_sw = max( hn_sw, water_hgt );
 	const sint8 disp_hn_se = max( hn_se, water_hgt );
 	const sint8 disp_hn_ne = max( hn_ne, water_hgt );
 	const sint8 disp_hn_nw = max( hn_nw, water_hgt );
-	const uint8 sneu = (disp_hn_sw - disp_hneu) + ((disp_hn_se - disp_hneu) * 3) + ((disp_hn_ne - disp_hneu) * 9) + ((disp_hn_nw - disp_hneu) * 27);
+	const uint8 sneu = (disp_hn_sw - disp_hneu) + ((disp_hn_se - disp_hneu) * slope_t::southeast) + ((disp_hn_ne - disp_hneu) * slope_t::northeast) + ((disp_hn_nw - disp_hneu) * slope_t::northwest);
 
 	bool ok = (hmaxneu - hneu <= max_hdiff); // may fail on water tiles since lookup_hgt might be modified from previous raise_to calls
 	if (!ok && !gr->is_water()) {
@@ -2454,7 +2454,7 @@
 		if(  grid_hgts[offset] < h  ) {
 			grid_hgts[offset] = h;
 
-			const sint8 hh = h - (ground_desc_t::double_grounds ? 2 : 1);
+			const sint8 hh = h - (ground_desc_t::triple_grounds ? 3 : (ground_desc_t::double_grounds ?  2 : 1));
 
 			// set new height of neighbor grid points
 			raise_grid_to(x-1, y-1, hh);
@@ -2485,8 +2485,8 @@
 
 		sint8 hsw, hse, hne, hnw;
 		if(  !gr->is_water()  ) {
-			const sint8 f = ground_desc_t::double_grounds ?  2 : 1;
-			const sint8 o = ground_desc_t::double_grounds ?  1 : 0;
+			const sint8 f = ground_desc_t::triple_grounds ? 3 : (ground_desc_t::double_grounds ?  2 : 1);
+			const sint8 o = ground_desc_t::triple_grounds ? 2 : (ground_desc_t::double_grounds ?  1 : 0);
 
 			hsw = hgt - o + scorner_sw( corner_to_raise ) * f;
 			hse = hgt - o + scorner_se( corner_to_raise ) * f;
@@ -2530,7 +2530,7 @@
 	const sint8 h0_ne = gr->is_water() ? min( water_hgt, lookup_hgt_nocheck(x,y+1) )   : h0 + corner_ne( gr->get_grund_hang() );
 	const sint8 h0_nw = gr->is_water() ? min( water_hgt, lookup_hgt_nocheck(x,y) )     : h0 + corner_nw( gr->get_grund_hang() );
 
-	const uint8 max_hdiff = ground_desc_t::double_grounds ?  2 : 1;
+	const uint8 max_hdiff = ground_desc_t::triple_grounds ? 3 : (ground_desc_t::double_grounds ?  2 : 1);
 
 	// sw
 	if (h0_sw > hsw) {
@@ -2706,7 +2706,7 @@
 	const sint8 disp_hn_se = max( hn_se, water_hgt );
 	const sint8 disp_hn_ne = max( hn_ne, water_hgt );
 	const sint8 disp_hn_nw = max( hn_nw, water_hgt );
-	const uint8 sneu = (disp_hn_sw - disp_hneu) + ((disp_hn_se - disp_hneu) * 3) + ((disp_hn_ne - disp_hneu) * 9) + ((disp_hn_nw - disp_hneu) * 27);
+	const uint8 sneu = (disp_hn_sw - disp_hneu) + ((disp_hn_se - disp_hneu) * slope_t::southeast) + ((disp_hn_ne - disp_hneu) * slope_t::northeast) + ((disp_hn_nw - disp_hneu) * slope_t::northwest);
 
 	// change height and slope for land tiles only
 	if(  !gr->is_water()  ||  (hmaxneu > water_hgt)  ) {
@@ -2811,8 +2811,8 @@
 		const sint16 y = gr->get_pos().y;
 		const sint8 hgt = gr->get_hoehe(corner_to_lower);
 
-		const sint8 f = ground_desc_t::double_grounds ?  2 : 1;
-		const sint8 o = ground_desc_t::double_grounds ?  1 : 0;
+		const sint8 f = ground_desc_t::triple_grounds ? 3 : (ground_desc_t::double_grounds ?  2 : 1);
+		const sint8 o = ground_desc_t::triple_grounds ? 2 : (ground_desc_t::double_grounds ?  1 : 0);
 		const sint8 hsw = hgt + o - scorner_sw( corner_to_lower ) * f;
 		const sint8 hse = hgt + o - scorner_se( corner_to_lower ) * f;
 		const sint8 hne = hgt + o - scorner_ne( corner_to_lower ) * f;
@@ -4375,7 +4375,7 @@
 		return slope_t::flat;
 	}
 	else {
-		const sint8 max_hdiff = ground_desc_t::double_grounds ? 2 : 1;
+		const sint8 max_hdiff = ground_desc_t::triple_grounds ? 3 : (ground_desc_t::double_grounds ?  2 : 1);
 
 		sint8 corner_height[4];
 
@@ -4453,7 +4453,7 @@
 		const sint16 d2 = min( corner_height[1] - new_height, max_hdiff );
 		const sint16 d3 = min( corner_height[2] - new_height, max_hdiff );
 		const sint16 d4 = min( corner_height[3] - new_height, max_hdiff );
-		return d4 * 27 + d3 * 9 + d2 * 3 + d1;
+		return d4 * slope_t::northwest + d3 * slope_t::northeast + d2 * slope_t::southeast + d1;
 	}
 	return 0;
 }
@@ -4477,7 +4477,7 @@
 		const int d3=h3-mini;
 		const int d4=h4-mini;
 
-		return d1 * 27 + d2 * 9 + d3 * 3 + d4;
+		return d1 * slope_t::northwest + d2 * slope_t::northeast + d3 * slope_t::southeast + d4;
 	}
 	return 0;
 }
@@ -5417,7 +5417,10 @@
 				sint8 slope;
 				file->rdwr_byte(slope);
 				// convert slopes from old single height saved game
-				slope = (scorner_sw(slope) + scorner_se(slope) * 3 + scorner_ne(slope) * 9 + scorner_nw(slope) * 27) * env_t::pak_height_conversion_factor;
+				slope = (scorner_sw(slope) +
+					scorner_se(slope) * slope_t::southeast +
+					scorner_ne(slope) * slope_t::northeast +
+					scorner_nw(slope) * slope_t::northwest) * env_t::pak_height_conversion_factor;
 				access_nocheck(x, y)->get_kartenboden()->set_grund_hang(slope);
 			}
 		}
@@ -5898,8 +5901,8 @@
 			grund_t *gr2 = pl2->get_kartenboden();
 			slope_t::type slope_corner = gr2->get_grund_hang();
 			for(  int j = 0;  j < 4;  j++  ) {
-				neighbour_height[i][j] = gr2->get_hoehe() + slope_corner % 3;
-				slope_corner /= 3;
+				neighbour_height[i][j] = gr2->get_hoehe() + slope_corner % slope_t::southeast;
+				slope_corner /= slope_t::southeast;
 			}
 		}
 		else {
@@ -6020,7 +6023,7 @@
 			// corner_se (i=1): tests vs neighbour 3:s (corner 3 j=2),4:se (corner 4) and 5:e (corner 1)
 			// corner_ne (i=2): tests vs neighbour 5:e (corner 4 j=3),6:ne (corner 1) and 7:n (corner 2)
 			// corner_nw (i=3): tests vs neighbour 7:n (corner 1 j=0),0:nw (corner 2) and 1:w (corner 3)
-			sint8 corner_height = gr->get_hoehe() + slope_corner % 3;
+			sint8 corner_height = gr->get_hoehe() + slope_corner % slope_t::southeast;
 
 			climate transition_climate = water_climate;
 			climate min_climate = arctic_climate;
@@ -6036,7 +6039,7 @@
 			if(  min_climate == water_climate  ||  transition_climate > climate0  ) {
 				climate_corners |= 1 << i;
 			}
-			slope_corner /= 3;
+			slope_corner /= slope_t::southeast;
 		}
 		pl->set_climate_transition_flag( climate_corners != 0 );
 		pl->set_climate_corners( climate_corners );