===================================================================
--- original.js
+++ change.js
@@ -350,54 +350,54 @@
 	2: {
 		totalBricks: 66,
 		hitpoints: 3,
 		gridSize: 200,
-		pattern: 'staggered'
+		pattern: 'grid'
 	},
 	3: {
 		totalBricks: 84,
-		hitpoints: 5,
+		hitpoints: 6,
 		gridSize: 320,
 		pattern: 'staggered'
 	},
 	4: {
-		totalBricks: 96,
-		hitpoints: 8,
-		gridSize: 280,
-		pattern: 'grid'
+		totalBricks: 102,
+		hitpoints: 10,
+		gridSize: 500,
+		pattern: 'clustered'
 	},
 	5: {
 		totalBricks: 96,
 		hitpoints: 12,
 		gridSize: 240,
 		pattern: 'grid'
 	},
 	6: {
-		totalBricks: 100,
+		totalBricks: 106,
 		hitpoints: 15,
 		gridSize: 220,
 		pattern: 'grid'
 	},
 	7: {
-		totalBricks: 110,
+		totalBricks: 106,
 		hitpoints: 20,
 		gridSize: 200,
 		pattern: 'grid'
 	},
 	8: {
-		totalBricks: 120,
+		totalBricks: 106,
 		hitpoints: 99,
 		gridSize: 180,
 		pattern: 'grid'
 	},
 	9: {
-		totalBricks: 130,
+		totalBricks: 106,
 		hitpoints: 9999,
 		gridSize: 160,
 		pattern: 'grid'
 	},
 	10: {
-		totalBricks: 140,
+		totalBricks: 106,
 		hitpoints: 999999,
 		gridSize: 140,
 		pattern: 'grid'
 	}
@@ -828,19 +828,43 @@
 				brickCount++;
 			}
 		}
 	} else if (pattern === 'clustered') {
-		// [Unchanged clustered pattern code]
-		var clusterCols = Math.floor(cols / 2);
-		var clusterRows = Math.floor(rows / 2);
-		var clusterStartX = GAME_WIDTH / 2 - clusterCols * BRICK_WIDTH / 2;
-		var clusterStartY = GAME_HEIGHT / 3 - clusterRows * BRICK_HEIGHT / 2;
-		for (var i = 0; i < clusterRows && brickCount < totalBricks; i++) {
-			for (var j = 0; j < clusterCols && brickCount < totalBricks; j++) {
-				addBrick(clusterStartX + j * (BRICK_WIDTH + spacingX), clusterStartY + i * (BRICK_HEIGHT + spacingY), baseHitpoints, gridSize);
-				brickCount++;
+		// Clustered pattern: fill from outside in
+		var centerRow = Math.floor(rows / 2);
+		var centerCol = Math.floor(cols / 2);
+		var maxDistance = Math.max(centerRow, centerCol);
+		// Create a list of all possible grid positions with their distances
+		var positions = [];
+		for (var i = 0; i < rows; i++) {
+			for (var j = 0; j < cols; j++) {
+				var rowDistance = Math.abs(i - centerRow);
+				var colDistance = Math.abs(j - centerCol);
+				var distance = Math.max(rowDistance, colDistance);
+				positions.push({
+					i: i,
+					j: j,
+					distance: distance
+				});
 			}
 		}
+		// Sort positions by distance (descending) to fill from outside in
+		positions.sort(function (a, b) {
+			return b.distance - a.distance;
+		});
+		// Place bricks up to totalBricks limit
+		for (var k = 0; k < positions.length && brickCount < totalBricks; k++) {
+			var pos = positions[k];
+			var i = pos.i;
+			var j = pos.j;
+			var distance = pos.distance;
+			var x = startX + j * (BRICK_WIDTH + spacingX);
+			var y = startY + i * (BRICK_HEIGHT + spacingY);
+			// Optional: HP can still vary if desired, higher on edges here
+			var hitpoints = Math.max(1, Math.round(baseHitpoints * (distance / maxDistance)));
+			addBrick(x, y, hitpoints, gridSize);
+			brickCount++;
+		}
 	} else if (pattern === 'diagonal') {
 		// [Unchanged diagonal pattern code]
 		var stepX = (GAME_WIDTH - BRICK_WIDTH) / (totalBricks - 1);
 		var stepY = GAME_HEIGHT / 3 / (totalBricks - 1);
@@ -849,17 +873,33 @@
 			addBrick(startX + i * stepX + offsetX, startY + i * stepY, baseHitpoints, gridSize);
 			brickCount++;
 		}
 	} else if (pattern === 'sparse') {
-		// [Unchanged sparse pattern code]
+		// Sparse pattern: groups of 3 rows with 2-row gaps
+		var groupSize = 3; // 3 rows per group
+		var gapSize = 2; // 2 rows gap
+		var cycleLength = groupSize + gapSize; // Total rows in one cycle (3 + 2 = 5)
 		while (brickCount < totalBricks) {
-			var x = startX + Math.floor(Math.random() * cols) * (BRICK_WIDTH + spacingX);
-			var y = startY + Math.floor(Math.random() * rows) * (BRICK_HEIGHT + spacingY);
-			if (!bricks.some(function (b) {
-				return b.x === x && b.y === y;
-			})) {
-				addBrick(x, y, baseHitpoints, gridSize);
-				brickCount++;
+			// Pick a random column
+			var col = Math.floor(Math.random() * cols);
+			var x = startX + col * (BRICK_WIDTH + spacingX);
+			// Pick a random group start row, ensuring space for 3 rows
+			var maxGroupStart = rows - groupSize; // Leave room for 3 rows
+			var groupStart = Math.floor(Math.random() * Math.floor(maxGroupStart / cycleLength)) * cycleLength;
+			// Place bricks in the 3 rows of the group
+			for (var rowOffset = 0; rowOffset < groupSize && brickCount < totalBricks; rowOffset++) {
+				var row = groupStart + rowOffset;
+				if (row >= rows) {
+					continue;
+				} // Skip if beyond grid bounds
+				var y = startY + row * (BRICK_HEIGHT + spacingY);
+				// Check for collision to maintain sparsity
+				if (!bricks.some(function (b) {
+					return b.x === x && b.y === y;
+				})) {
+					addBrick(x, y, baseHitpoints, gridSize);
+					brickCount++;
+				}
 			}
 		}
 	}
 	brickGridBounds = {