/**** 
* Classes
****/ 
// Background class
var Background = Container.expand(function () {
	var self = Container.call(this);
	var backgroundGraphics = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set background speed
	self.speed = -2;
	// This is automatically called every game tick, if the background is attached!
	self.update = function () {
		// Move the background downwards
		self.y += self.speed;
		// Reset the position of the background when it reaches the end
		if (self.y <= -2732) {
			self.y = 2732;
		}
	};
});
// Diver class
var Diver = Container.expand(function () {
	var self = Container.call(this);
	var diverGraphics = self.attachAsset('diver', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add a sideways movement to the diver
	self.movement = 0;
	self.direction = 1;
	self.update = function () {
		self.movement += self.direction * 0.03;
		if (self.movement > 0.5 || self.movement < -0.5) {
			self.direction *= -1;
		}
		self.x += self.movement;
	};
	// Add flippers to the diver
	var leftFlipper = self.addChild(new Flipper());
	leftFlipper.x = -50;
	leftFlipper.depth = -1;
	var rightFlipper = self.addChild(new Flipper());
	rightFlipper.x = 50;
	rightFlipper.depth = -1;
});
// Flipper class
var Flipper = Container.expand(function () {
	var self = Container.call(this);
	var flipperGraphics = self.attachAsset('flippers', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	// Set flipper movement
	self.movement = 0;
	self.direction = 1;
	// This is automatically called every game tick, if the flipper is attached!
	self.update = function () {
		// Move the flipper subtly to simulate flipping
		self.movement += self.direction * 0.03;
		if (self.movement > 0.5 || self.movement < -0.5) {
			self.direction *= -1;
		}
		self.rotation = self.movement;
	};
});
// Obstacle1 class
var Obstacle1 = Container.expand(function () {
	var self = Container.call(this);
	var obstacle1Graphics = self.attachAsset('obstacle1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set obstacle1 speed
	self.speed = -5;
	// This is automatically called every game tick, if the obstacle1 is attached!
	self.update = function () {
		// Check if the obstacle is colliding with the shield
		if (pixelPerfectCollision(self, shield)) {
			// Calculate the direction vector between the shield and the obstacle
			var dx = self.x - shield.x;
			var dy = self.y - shield.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Normalize the direction vector
			dx /= distance;
			dy /= distance;
			// Push the obstacle away from the shield
			self.x += dx * 5;
			self.y += dy * 5;
		}
		// Check for collision with diver
		if (pixelPerfectCollision(self, diver)) {
			// Flash screen red for 1 second (1000ms) to show game over
			LK.effects.flashScreen(0xff0000, 1000);
			// Show game over. The game will be automatically paused while game over is showing.
			LK.showGameOver();
		}
		// Continue moving upwards
		self.y += self.speed;
		self.rotation += 0.01; // Add small rotation to the obstacle
		// Add size change to the obstacle
		self.scale.x = 1 + Math.sin(LK.ticks / 10) * 0.02;
		self.scale.y = 1 + Math.sin(LK.ticks / 10) * 0.02;
		if (self.y < 0) {
			self.destroy();
			var index = obstacles.indexOf(self);
			if (index > -1) {
				obstacles.splice(index, 1);
			}
		}
		// Check if the obstacle is colliding with another obstacle
		for (var i = 0; i < obstacles.length; i++) {
			var otherObstacle = obstacles[i];
			if (self !== otherObstacle && pixelPerfectCollision(self, otherObstacle)) {
				// Calculate the direction vector between the two obstacles
				var dx = self.x - otherObstacle.x;
				var dy = self.y - otherObstacle.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				// Normalize the direction vector
				dx /= distance;
				dy /= distance;
				// Push the obstacle away from the other obstacle
				self.x += dx * 5;
				self.y += dy * 5;
			}
		}
	};
});
// Shield class
var Shield = Container.expand(function () {
	var self = Container.call(this);
	var shieldGraphics = self.attachAsset('shield', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.down = function (x, y, obj) {
		dragNode = self;
	};
});

/**** 
* Initialize Game
****/ 
// Create a diver instance
//<Assets used in the game will automatically appear here>
var game = new LK.Game({
	backgroundColor: 0xADD8E6 //Init game with light blue background
});

/**** 
* Game Code
****/ 
/**
* Check for pixel-perfect collision between two display objects.
* @param {DisplayObject} obj1 - The first display object.
* @param {DisplayObject} obj2 - The second display object.
* @returns {boolean} - True if there is a pixel-perfect collision, false otherwise.
*/
function pixelPerfectCollision(obj1, obj2) {
	var bounds1 = obj1.getBounds();
	var bounds2 = obj2.getBounds();
	// Check if bounding boxes intersect
	if (!bounds1.intersects(bounds2)) {
		return false;
	}
	// Create a canvas to draw the objects
	var canvas = document.createElement('canvas');
	var context = canvas.getContext('2d');
	// Set canvas size to the intersection of the bounding boxes
	var width = Math.min(bounds1.right, bounds2.right) - Math.max(bounds1.left, bounds2.left);
	var height = Math.min(bounds1.bottom, bounds2.bottom) - Math.max(bounds1.top, bounds2.top);
	canvas.width = width;
	canvas.height = height;
	// Draw the first object
	context.clearRect(0, 0, width, height);
	context.save();
	context.translate(-Math.max(bounds1.left, bounds2.left), -Math.max(bounds1.top, bounds2.top));
	obj1.render(context);
	context.restore();
	var imageData1 = context.getImageData(0, 0, width, height).data;
	// Draw the second object
	context.clearRect(0, 0, width, height);
	context.save();
	context.translate(-Math.max(bounds1.left, bounds2.left), -Math.max(bounds1.top, bounds2.top));
	obj2.render(context);
	context.restore();
	var imageData2 = context.getImageData(0, 0, width, height).data;
	// Check for pixel-perfect collision
	for (var i = 0; i < imageData1.length; i += 4) {
		if (imageData1[i + 3] > 0 && imageData2[i + 3] > 0) {
			return true;
		}
	}
	return false;
}
// Create a shield instance
var shield = game.addChildAt(new Shield(), game.children.length);
// Position the shield at the center of the screen
shield.x = 2048 / 2;
shield.y = 2732 / 2;
// Create a diver instance
var dragNode = null;
var diver = new Diver();
diver.depth = 2;
// Position the diver at the top center of the screen, 200 pixels down from the top
diver.x = 2048 / 2;
diver.y = 500;
// Position the flippers relative to the diver
diver.children[0].y = diver.height / 2 - 20; // Left flipper
diver.children[0].y = diver.children[0].y; // Right flipper
// Set diver to a higher depth than flippers
diver.depth = 2;
// Create an obstacle1 instance
game.move = function (x, y, obj) {
	if (dragNode) {
		dragNode.x = x;
		dragNode.y = y;
	}
};
var obstacles = [];
var background1 = game.addChildAt(new Background(), 0);
background1.x = 2048 / 2;
background1.y = 2732 / 2;
var background2 = game.addChildAt(new Background(), 0);
background2.x = 2048 / 2;
background2.y = 2732 / 2 + 2732;
game.addChild(diver);
game.setChildIndex(diver, game.children.length - 1);
// Spawn the first wave of obstacles
spawnWave();
;
// Initialize score
var score = 0;
// Create score text
var scoreText = new Text2('Depth: 0m', {
	size: 50,
	fill: "#ffffff"
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
// Initialize a timer to update the score every second
var scoreUpdateInterval = LK.setInterval(function () {
	score += 1;
	if (scoreText) {
		scoreText.setText('Depth: ' + score + 'm');
	}
}, 2000);
game.up = function (x, y, obj) {
	dragNode = null;
};
// Define the number of obstacles in each wave
var obstaclesPerWave = [2, 3, 4, 5, 6];
var currentWave = 0;
// Spawn wave function
function spawnWave() {
	// Check if the previous wave is destroyed
	if (obstacles && obstacles.length === 0) {
		// Define the layout of the obstacles for each wave
		var obstacleLayouts = [
		// First wave: four obstacles forming a square
		'square',
		// Second wave: three obstacles forming a triangle
		'triangle',
		// Third wave: ten obstacles forming a circle
		'circle'];
		// Get the layout for the current wave
		var layout = obstacleLayouts[currentWave];
		// Define the positions for each layout
		var positions = {
			'square': [{
				x: 2,
				y: 2
			}, {
				x: 2,
				y: 7
			}, {
				x: 7,
				y: 2
			}, {
				x: 7,
				y: 7
			}],
			'triangle': [{
				x: 5,
				y: 2
			}, {
				x: 2,
				y: 7
			}, {
				x: 8,
				y: 7
			}],
			'circle': [{
				x: 5,
				y: 2
			}, {
				x: 6,
				y: 3
			}, {
				x: 7,
				y: 4
			}, {
				x: 7,
				y: 5
			}, {
				x: 6,
				y: 6
			}, {
				x: 5,
				y: 7
			}, {
				x: 4,
				y: 6
			}, {
				x: 3,
				y: 5
			}, {
				x: 3,
				y: 4
			}, {
				x: 4,
				y: 3
			}]
		};
		// Get the positions for the current layout
		var layoutPositions = positions[layout];
		if (!layoutPositions) {
			console.error('Error: layoutPositions is undefined. Check the layout variable and the positions object.');
			return;
		}
		for (var i = 0; i < layoutPositions.length; i++) {
			var obstacle = game.addChild(new Obstacle1());
			// Position the obstacles according to the layout, using the grid for positioning
			obstacle.x = 2048 / 2 + (layoutPositions[i].x - gridSize / 2) * cellSize;
			obstacle.y = 2732 + layoutPositions[i].y * cellSize; // Spawn obstacles offscreen at the bottom
			obstacles.push(obstacle);
		}
		currentWave++;
		if (obstaclesPerWave && currentWave >= obstaclesPerWave.length) {
			currentWave = 0;
		}
	}
}
// Define the grid size and the size of each cell in the grid
var gridSize = 10;
var cellSize = 50;
// Call the spawn wave function every 2 seconds
var spawnWaveInterval = LK.setInterval(spawnWave, 2000);
;

===================================================================
--- original.js
+++ change.js
@@ -76,9 +76,9 @@
 	self.speed = -5;
 	// This is automatically called every game tick, if the obstacle1 is attached!
 	self.update = function () {
 		// Check if the obstacle is colliding with the shield
-		if (Math.abs(self.x - shield.x) < self.width / 2 + shield.width / 2 && Math.abs(self.y - shield.y) < self.height / 2 + shield.height / 2) {
+		if (pixelPerfectCollision(self, shield)) {
 			// Calculate the direction vector between the shield and the obstacle
 			var dx = self.x - shield.x;
 			var dy = self.y - shield.y;
 			var distance = Math.sqrt(dx * dx + dy * dy);
@@ -89,9 +89,9 @@
 			self.x += dx * 5;
 			self.y += dy * 5;
 		}
 		// Check for collision with diver
-		if (Math.abs(self.x - diver.x) < self.width / 2 + diver.width / 2 && Math.abs(self.y - diver.y) < self.height / 2 + diver.height / 2) {
+		if (pixelPerfectCollision(self, diver)) {
 			// Flash screen red for 1 second (1000ms) to show game over
 			LK.effects.flashScreen(0xff0000, 1000);
 			// Show game over. The game will be automatically paused while game over is showing.
 			LK.showGameOver();
@@ -111,9 +111,9 @@
 		}
 		// Check if the obstacle is colliding with another obstacle
 		for (var i = 0; i < obstacles.length; i++) {
 			var otherObstacle = obstacles[i];
-			if (self !== otherObstacle && Math.abs(self.x - otherObstacle.x) < self.width / 2 + otherObstacle.width / 2 && Math.abs(self.y - otherObstacle.y) < self.height / 2 + otherObstacle.height / 2) {
+			if (self !== otherObstacle && pixelPerfectCollision(self, otherObstacle)) {
 				// Calculate the direction vector between the two obstacles
 				var dx = self.x - otherObstacle.x;
 				var dy = self.y - otherObstacle.y;
 				var distance = Math.sqrt(dx * dx + dy * dy);
@@ -150,8 +150,51 @@
 
 /**** 
 * Game Code
 ****/ 
+/**
+* Check for pixel-perfect collision between two display objects.
+* @param {DisplayObject} obj1 - The first display object.
+* @param {DisplayObject} obj2 - The second display object.
+* @returns {boolean} - True if there is a pixel-perfect collision, false otherwise.
+*/
+function pixelPerfectCollision(obj1, obj2) {
+	var bounds1 = obj1.getBounds();
+	var bounds2 = obj2.getBounds();
+	// Check if bounding boxes intersect
+	if (!bounds1.intersects(bounds2)) {
+		return false;
+	}
+	// Create a canvas to draw the objects
+	var canvas = document.createElement('canvas');
+	var context = canvas.getContext('2d');
+	// Set canvas size to the intersection of the bounding boxes
+	var width = Math.min(bounds1.right, bounds2.right) - Math.max(bounds1.left, bounds2.left);
+	var height = Math.min(bounds1.bottom, bounds2.bottom) - Math.max(bounds1.top, bounds2.top);
+	canvas.width = width;
+	canvas.height = height;
+	// Draw the first object
+	context.clearRect(0, 0, width, height);
+	context.save();
+	context.translate(-Math.max(bounds1.left, bounds2.left), -Math.max(bounds1.top, bounds2.top));
+	obj1.render(context);
+	context.restore();
+	var imageData1 = context.getImageData(0, 0, width, height).data;
+	// Draw the second object
+	context.clearRect(0, 0, width, height);
+	context.save();
+	context.translate(-Math.max(bounds1.left, bounds2.left), -Math.max(bounds1.top, bounds2.top));
+	obj2.render(context);
+	context.restore();
+	var imageData2 = context.getImageData(0, 0, width, height).data;
+	// Check for pixel-perfect collision
+	for (var i = 0; i < imageData1.length; i += 4) {
+		if (imageData1[i + 3] > 0 && imageData2[i + 3] > 0) {
+			return true;
+		}
+	}
+	return false;
+}
 // Create a shield instance
 var shield = game.addChildAt(new Shield(), game.children.length);
 // Position the shield at the center of the screen
 shield.x = 2048 / 2;