smoothed out floors

Author: drademacher

src/display/Bitmap.java

@@ -17,7 +17,8 @@ public class Bitmap extends JPanel {
 	final int offsetX = 0, offsetY = 0;
 	int fieldSize = 5, padding = 0, rectSize = fieldSize - padding;
 
-	private Color[] color = { Color.decode("#A1D490"), Color.decode("#D4B790"), Color.decode("#801B1B"),
+	private Color[] color = { Color.decode("#454545"), Color.decode("#A1D490"), Color.decode("#D4B790"),
+			Color.decode("#B39B7B"), Color.decode("#801B1B"), Color.decode("#000000") };
 
 	public void setRoom(Map map) {
 		this.map = map;

src/dungeon/Cell.java

@@ -5,17 +5,30 @@ public class Cell {
 	private int x, y;
 	private Ground ground;
 
+	/**
+	 * public constructor, default ground is wall (no passing)
+	 * @param x
+	 * @param y
+	 */
 	public Cell(int x, int y) {
 		this.x = x;
 		this.y = y;
 		this.ground = Ground.WALL;
 	}
 
-	public void set(Ground ground) {
+	/**
+	 * setter method for ground state
+	 * @param ground
+	 */
+	public void setGround(Ground ground) {
 		this.ground = ground;
 	}
 
-	public Ground get() {
+	/**
+	 * getter method for ground state
+	 * @return
+	 */
+	public Ground getGround() {
 		return ground;
 	}
 }

src/dungeon/Generator.java

@@ -23,8 +23,8 @@ public class Generator {
 	// constants
 
 	final int ROOM_LIMIT = 300;
-	final int[][] neighsAll = new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, 1 } };
-	final int[][] neighsOdd = new int[][] { { 2, 0 }, { -2, 0 }, { 0, 2 }, { 0, 2 } };
+	final int[][] neighsAll = new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
+	final int[][] neighsOdd = new int[][] { { 2, 0 }, { -2, 0 }, { 0, 2 }, { 0, -2 } };
 
 	/**
 	 * constructor for generate levels with some fixed size
@@ -53,7 +53,8 @@ public Map newLevel() {
 		// 4 general steps to level generation
 		placeRooms();
 		placeMaze();
-		removeDeadends(5);
+		removeDeadends();
+		plazeLoops();
 
 		return map;
 	}
@@ -94,7 +95,7 @@ private void placeRooms() {
 			}
 
 			// place room
-			map.newRoom(xStart, xLen, yStart, yLen);
+			map.setNewRoom(xStart, xLen, yStart, yLen);
 
 			// insert room into memory
 			roomTable[roomNum] = new int[] { xStart, xLen, yStart, yLen };
@@ -235,37 +236,56 @@ private void connectRoom(int xStart, int xLen, int yStart, int yLen) {
 				break;
 			}
 			int l = rand.nextInt(k);
-			map.setGround(candidates[l][0], candidates[l][1], CONNECTOR);
+			map.setGround(candidates[l][0], candidates[l][1], FLOOR);
 		} while (rand.nextDouble() < 0.3);
 	}
 
 	/**
 	 * internal function to remove the dead ends of the maze
 	 */
-	@SuppressWarnings("unused")
-	private void removeDeadends(int iter) {
-		// declarations
-		Queue<int[]> q = new ArrayDeque<int[]>();
-		int cur[], perm[], neigh[][];
-
-		// push every cell on stack
-		// because connectors cannot be a dead end
-		for (int i = 0; i < n; i += 1) {
-			for (int j = 0; j < m; j += 1) {
-				if (map.getGround(i, j) != WALL) {
-					q.add(new int[] { i, j });
+	private void removeDeadends() {
+		int count;
+		boolean repeat = true, deadend[][];
+
+		while (repeat) {
+			// fresh inits for single execution of elemination
+			deadend = new boolean[n][m];
+			repeat = false;
+
+			// dead end iff 3 neighbours are walls
+			for (int x = 0; x < n; x++) {
+				for (int y = 0; y < m; y++) {
+					if (map.getGround(x, y) == WALL) {
+						continue;
+					}
+
+					count = 0;
+					for (int j = 0; j < 4; j++) {
+						if (map.getGround(x + neighsAll[j][0], y + neighsAll[j][1]) == WALL)
+							count++;
+					}
+
+					if (count == 3) {
+						deadend[x][y] = true;
+						repeat = true;
+					}
 				}
 			}
-		}
-		q.add(new int[] { -1, -1 });
-
-		// remove if dead end and push the neighbour on stack which might be a
-		// dead end now
-		while (!q.isEmpty()) {
-			cur = q.poll();
 
+			// remove dead ends
+			for (int x = 0; x < n; x++) {
+				for (int y = 0; y < m; y++) {
+					if (deadend[x][y])
+						map.setGround(x, y, WALL);
+				}
+			}
 		}
-
 	}
 
+	/**
+	 * internal function to create loops inside the map
+	 */
+	private void plazeLoops() {
+
+	}
 }

src/dungeon/Ground.java

@@ -3,7 +3,6 @@
 public enum Ground {
 	WALL,
 	FLOOR,
-	CONNECTOR,
 	DOOR,
 	ROOM,
 	ERROR

src/dungeon/Map.java

@@ -20,43 +20,76 @@ public Map(int n, int m) {
 		for (int i = 0; i < n; i++) {
 			for (int j = 0; j < m; j++) {
 				map[i][j] = new Cell(i, j);
-				map[i][j].set(WALL);
+				map[i][j].setGround(WALL);
 			}
 		}
 	}
-
+	
+	/**
+	 * getter method for length n
+	 * @return n
+	 */
 	public int getN() {
 		return n;
 	}
-
+	
+	/**
+	 * getter method for length m
+	 * @return m
+	 */
 	public int getM() {
 		return m;
 	}
 
+	/**
+	 * setter method for cell
+	 * @param x coordinate
+	 * @param y coordinate
+	 * @return
+	 */
 	public Cell getCell(int x, int y) {
 		return map[x][y];
 	}
-
+	
+	/**
+	 * getther method for ground state
+	 * @param x coordinate
+	 * @param y coordinate
+	 * @return
+	 */
 	public Ground getGround(int x, int y) {
 		if (x < 0 || x >= n || y < 0 || y >= m) {
 			return ERROR;
 		}
 
-		return map[x][y].get();
+		return map[x][y].getGround();
 	}
-
+	
+	/**
+	 * setter method for ground state
+	 * @param x
+	 * @param y
+	 * @param ground
+	 */
 	public void setGround(int x, int y, Ground ground) {
 		if (x < 0 || x >= n || y < 0 || y >= m) {
 			return;
 		}
 
-		map[x][y].set(ground);
+		map[x][y].setGround(ground);
 	}
-
-	public void newRoom(int xStart, int xLen, int yStart, int yLen) {
+	
+	/**
+	 * setter method for a new room on the map object
+	 * @param xStart
+	 * @param xLen
+	 * @param yStart
+	 * @param yLen
+	 */
+	public void setNewRoom(int xStart, int xLen, int yStart, int yLen) {
 		for (int x = xStart; x < xStart + xLen; x++) {
 			for (int y = yStart; y < yStart + yLen; y++) {
-				map[x][y].set(ROOM);
+				map[x][y].setGround(ROOM);
 			}
 		}
 	}