Upit | Learn about creating the game Sweet Cascades with gen AI
Play
game-community-background
game-pic

12

0

1y

Playit
Step into a world of sugary bliss with Sweet Cascades, the ultimate candy-matching adventure! Swipe, match, and blast your way through a grid full of vibrant candies, each bursting with color and excitement.
#match3
#candy
#cascade
#sweetgame

Creation History

User prompt

I still can't

User prompt

Please fix the bug: 'Timeout.tick error: Cannot set properties of null (setting 'gridX')' in or related to this line: 'selectedCandy.gridX = oldGrid1.x;' Line Number: 441

Code edit (1 edits merged)

Please save this source code

User prompt

Sweet Cascades

Initial prompt

import pygame import random import sys from pygame.locals import * # Initialize pygame pygame.init() # Constants SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 GRID_SIZE = 8 CELL_SIZE = 64 GRID_OFFSET_X = (SCREEN_WIDTH - GRID_SIZE * CELL_SIZE) // 2 GRID_OFFSET_Y = 150 FPS = 60 # Colors WHITE = (255, 255, 255) BLACK = (0, 0, 0) BACKGROUND_COLOR = (253, 245, 230) # Creamy background # Candy colors CANDY_COLORS = [ (255, 50, 50), # Red (50, 255, 50), # Green (50, 50, 255), # Blue (255, 255, 50), # Yellow (255, 50, 255), # Purple (50, 255, 255), # Cyan ] class Candy: def __init__(self, row, col, color_idx): self.row = row self.col = col self.color_idx = color_idx self.x = 0 self.y = 0 self.target_y = 0 self.target_x = 0 self.is_moving = False self.is_selected = False self.special_type = None # 'bomb', 'rainbow', 'lollipop' def update_position(self): if self.x < self.target_x: self.x += 5 self.is_moving = True elif self.x > self.target_x: self.x -= 5 self.is_moving = True else: self.x = self.target_x if self.y < self.target_y: self.y += 5 self.is_moving = True elif self.y > self.target_y: self.y -= 5 self.is_moving = True else: self.y = self.target_y self.is_moving = False def draw(self, surface): color = CANDY_COLORS[self.color_idx] rect = pygame.Rect( GRID_OFFSET_X + self.col * CELL_SIZE + self.x + 5, GRID_OFFSET_Y + self.row * CELL_SIZE + self.y + 5, CELL_SIZE - 10, CELL_SIZE - 10 ) # Draw candy base pygame.draw.rect(surface, color, rect, border_radius=10) # Add candy highlights highlight = pygame.Surface((CELL_SIZE-10, CELL_SIZE-10), pygame.SRCALPHA) pygame.draw.rect(highlight, (*color[:3], 50), highlight.get_rect(), border_radius=10) surface.blit(highlight, rect) # Draw selection border if self.is_selected: pygame.draw.rect(surface, WHITE, rect, 3, border_radius=10) # Draw special candy indicators if self.special_type == 'bomb': pygame.draw.circle(surface, BLACK, rect.center, 10) elif self.special_type == 'rainbow': for i in range(6): pygame.draw.arc(surface, CANDY_COLORS[i], rect, i * 0.8, (i+1) * 0.8, 5) elif self.special_type == 'lollipop': pygame.draw.circle(surface, WHITE, rect.center, 15, 3) class Game: def __init__(self): self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption("Sweet Cascades") self.clock = pygame.time.Clock() self.font = pygame.font.SysFont('Arial', 24) self.big_font = pygame.font.SysFont('Arial', 36) self.grid = [] self.selected_candy = None self.score = 0 self.moves_left = 30 self.level = 1 self.target_score = 1000 self.initialize_grid() def initialize_grid(self): self.grid = [] for row in range(GRID_SIZE): grid_row = [] for col in range(GRID_SIZE): # Make sure we don't create matches at the start while True: color_idx = random.randint(0, len(CANDY_COLORS) - 1) # Check horizontal matches if col >= 2: if (grid_row[col-1].color_idx == color_idx and grid_row[col-2].color_idx == color_idx): continue # Check vertical matches if row >= 2: if (self.grid[row-1][col].color_idx == color_idx and self.grid[row-2][col].color_idx == color_idx): continue break candy = Candy(row, col, color_idx) candy.target_x = 0 candy.target_y = 0 grid_row.append(candy) self.grid.append(grid_row) def draw(self): # Draw background self.screen.fill(BACKGROUND_COLOR) # Draw title title = self.big_font.render("Sweet Cascades", True, (200, 50, 100)) self.screen.blit(title, (SCREEN_WIDTH // 2 - title.get_width() // 2, 20)) # Draw score and moves score_text = self.font.render(f"Score: {self.score}", True, BLACK) moves_text = self.font.render(f"Moves: {self.moves_left}", True, BLACK) level_text = self.font.render(f"Level: {self.level}", True, BLACK) target_text = self.font.render(f"Target: {self.target_score}", True, BLACK) self.screen.blit(score_text, (50, 80)) self.screen.blit(moves_text, (200, 80)) self.screen.blit(level_text, (350, 80)) self.screen.blit(target_text, (500, 80)) # Draw grid background grid_bg = pygame.Rect( GRID_OFFSET_X - 5, GRID_OFFSET_Y - 5, GRID_SIZE * CELL_SIZE + 10, GRID_SIZE * CELL_SIZE + 10 ) pygame.draw.rect(self.screen, (220, 220, 220), grid_bg, border_radius=15) # Draw candies for row in self.grid: for candy in row: candy.draw(self.screen) # Draw game over or level complete message if self.moves_left <= 0: if self.score >= self.target_score: message = self.big_font.render("Level Complete!", True, (0, 200, 0)) else: message = self.big_font.render("Game Over!", True, (200, 0, 0)) self.screen.blit(message, (SCREEN_WIDTH // 2 - message.get_width() // 2, SCREEN_HEIGHT - 100)) pygame.display.flip() def handle_click(self, pos): if self.moves_left <= 0: return x, y = pos # Check if click is within grid if (GRID_OFFSET_X <= x < GRID_OFFSET_X + GRID_SIZE * CELL_SIZE and GRID_OFFSET_Y <= y < GRID_OFFSET_Y + GRID_SIZE * CELL_SIZE): col = (x - GRID_OFFSET_X) // CELL_SIZE row = (y - GRID_OFFSET_Y) // CELL_SIZE if 0 <= row < GRID_SIZE and 0 <= col < GRID_SIZE: clicked_candy = self.grid[row][col] if self.selected_candy is None: # First selection self.selected_candy = clicked_candy clicked_candy.is_selected = True else: # Second selection - check if adjacent if (abs(self.selected_candy.row - clicked_candy.row) == 1 and self.selected_candy.col == clicked_candy.col) or ( abs(self.selected_candy.col - clicked_candy.col) == 1 and self.selected_candy.row == clicked_candy.row): # Swap candies self.swap_candies(self.selected_candy, clicked_candy) self.moves_left -= 1 # Check for matches after swap matches = self.find_matches() if not matches: # No matches, swap back self.swap_candies(self.selected_candy, clicked_candy) self.moves_left += 1 else: # Process matches self.process_matches(matches) # Deselect self.selected_candy.is_selected = False self.selected_candy = None clicked_candy.is_selected = False def swap_candies(self, candy1, candy2): # Swap positions in grid self.grid[candy1.row][candy1.col], self.grid[candy2.row][candy2.col] = ( self.grid[candy2.row][candy2.col], self.grid[candy1.row][candy1.col] ) # Swap row and col attributes candy1.row, candy2.row = candy2.row, candy1.row candy1.col, candy2.col = candy2.col, candy1.col # Set target positions for animation candy1.target_x = 0 candy1.target_y = 0 candy2.target_x = 0 candy2.target_y = 0 def find_matches(self): matches = [] # Check horizontal matches for row in range(GRID_SIZE): for col in range(GRID_SIZE - 2): if (self.grid[row][col].color_idx == self.grid[row][col+1].color_idx == self.grid[row][col+2].color_idx): match = [] # Find all consecutive matching candies for c in range(col, GRID_SIZE): if self.grid[row][c].color_idx == self.grid[row][col].color_idx: match.append(self.grid[row][c]) else: break if len(match) >= 3: matches.append(match) # Check vertical matches for col in range(GRID_SIZE): for row in range(GRID_SIZE - 2): if (self.grid[row][col].color_idx == self.grid[row+1][col].color_idx == self.grid[row+2][col].color_idx): match = [] # Find all consecutive matching candies for r in range(row, GRID_SIZE): if self.grid[r][col].color_idx == self.grid[row][col].color_idx: match.append(self.grid[r][col]) else: break if len(match) >= 3: matches.append(match) return matches def process_matches(self, matches): # Create special candies for larger matches for match in matches: if len(match) == 4: # Create a bomb (random candy in the match) candy = random.choice(match) candy.special_type = 'bomb' elif len(match) >= 5: # Create a rainbow candy (first candy in the match) match[0].special_type = 'rainbow' # Lollipop could be created for L or T shapes (not implemented here) # Remove matched candies and calculate score matched_positions = set() for match in matches: for candy in match: if (candy.row, candy.col) not in matched_positions: matched_positions.add((candy.row, candy.col)) self.score += 10 * len(match) # Special candy effects if candy.special_type == 'bomb': self.score += 50 # Clear row and column for r in range(GRID_SIZE): matched_positions.add((r, candy.col)) for c in range(GRID_SIZE): matched_positions.add((candy.row, c)) elif candy.special_type == 'rainbow': self.score += 100 # Clear all candies of same color color = candy.color_idx for row in self.grid: for c in row: if c.color_idx == color: matched_positions.add((c.row, c.col)) # Remove matched candies for row, col in matched_positions: self.grid[row][col] = None # Drop candies down self.drop_candies() # Fill empty spaces self.fill_empty_spaces() # Check for new matches after filling new_matches = self.find_matches() if new_matches: self.process_matches(new_matches) def drop_candies(self): for col in range(GRID_SIZE): # Count empty spaces in column empty_rows = [] for row in range(GRID_SIZE-1, -1, -1): if self.grid[row][col] is None: empty_rows.append(row) elif empty_rows: # Move candy down to the lowest empty space lowest_empty = empty_rows.pop(0) self.grid[lowest_empty][col] = self.grid[row][col] self.grid[row][col] = None self.grid[lowest_empty][col].row = lowest_empty self.grid[lowest_empty][col].target_y = 0 empty_rows.append(row) def fill_empty_spaces(self): for row in range(GRID_SIZE): for col in range(GRID_SIZE): if self.grid[row][col] is None: color_idx = random.randint(0, len(CANDY_COLORS) - 1) candy = Candy(row, col, color_idx) candy.target_y = -CELL_SIZE # Start above the grid for falling animation candy.y = -CELL_SIZE self.grid[row][col] = candy def update(self): # Update candy positions for animations for row in self.grid: for candy in row: if candy: candy.update_position() # Check level completion if self.score >= self.target_score and self.moves_left > 0: self.level += 1 self.target_score += self.level * 500 self.moves_left = 30 self.initialize_grid() def run(self): running = True while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == MOUSEBUTTONDOWN: self.handle_click(event.pos) self.update() self.draw() self.clock.tick(FPS) pygame.quit() sys.exit() if __name__ == "__main__": game = Game() game.run()

===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,477 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
+* Classes
+****/ 
+var Candy = Container.expand(function (type) {
+	var self = Container.call(this);
+	self.candyType = type || 0;
+	self.isSpecial = false;
+	self.specialType = 'normal'; // 'normal', 'bomb', 'rainbow'
+	self.gridX = 0;
+	self.gridY = 0;
+	self.isAnimating = false;
+	self.isSelected = false;
+	var candyTypes = ['candy_red', 'candy_blue', 'candy_green', 'candy_yellow', 'candy_purple', 'candy_orange'];
+	var assetId = candyTypes[self.candyType] || candyTypes[0];
+	self.candyGraphics = self.attachAsset(assetId, {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.makeSpecial = function (specialType) {
+		self.isSpecial = true;
+		self.specialType = specialType;
+		if (specialType === 'bomb') {
+			self.removeChild(self.candyGraphics);
+			self.candyGraphics = self.attachAsset('bomb_candy', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		} else if (specialType === 'rainbow') {
+			self.removeChild(self.candyGraphics);
+			self.candyGraphics = self.attachAsset('rainbow_candy', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		}
+	};
+	self.setSelected = function (selected) {
+		self.isSelected = selected;
+		if (selected) {
+			self.candyGraphics.scaleX = 1.2;
+			self.candyGraphics.scaleY = 1.2;
+		} else {
+			self.candyGraphics.scaleX = 1.0;
+			self.candyGraphics.scaleY = 1.0;
+		}
+	};
+	self.down = function (x, y, obj) {
+		if (!self.isAnimating) {
+			handleCandyClick(self);
+		}
+	};
+	return self;
+});
+var GameGrid = Container.expand(function () {
+	var self = Container.call(this);
+	self.gridSize = 8;
+	self.cellSize = 120;
+	self.grid = [];
+	self.backgroundCells = [];
+	self.init = function () {
+		// Create background grid
+		for (var row = 0; row < self.gridSize; row++) {
+			for (var col = 0; col < self.gridSize; col++) {
+				var bgCell = self.attachAsset('grid_bg', {
+					anchorX: 0.5,
+					anchorY: 0.5
+				});
+				bgCell.x = col * self.cellSize;
+				bgCell.y = row * self.cellSize;
+				bgCell.alpha = 0.3;
+				self.backgroundCells.push(bgCell);
+			}
+		}
+		// Initialize grid array
+		for (var row = 0; row < self.gridSize; row++) {
+			self.grid[row] = [];
+			for (var col = 0; col < self.gridSize; col++) {
+				self.grid[row][col] = null;
+			}
+		}
+		// Fill grid with candies ensuring no initial matches
+		self.fillGrid();
+	};
+	self.fillGrid = function () {
+		for (var row = 0; row < self.gridSize; row++) {
+			for (var col = 0; col < self.gridSize; col++) {
+				if (!self.grid[row][col]) {
+					var candyType = self.getValidCandyType(row, col);
+					var candy = new Candy(candyType);
+					candy.gridX = col;
+					candy.gridY = row;
+					candy.x = col * self.cellSize;
+					candy.y = row * self.cellSize;
+					self.grid[row][col] = candy;
+					self.addChild(candy);
+				}
+			}
+		}
+	};
+	self.getValidCandyType = function (row, col) {
+		var invalidTypes = [];
+		// Check horizontal matches
+		if (col >= 2) {
+			var type1 = self.grid[row][col - 1] ? self.grid[row][col - 1].candyType : -1;
+			var type2 = self.grid[row][col - 2] ? self.grid[row][col - 2].candyType : -1;
+			if (type1 === type2 && type1 !== -1) {
+				invalidTypes.push(type1);
+			}
+		}
+		// Check vertical matches
+		if (row >= 2) {
+			var type1 = self.grid[row - 1][col] ? self.grid[row - 1][col].candyType : -1;
+			var type2 = self.grid[row - 2][col] ? self.grid[row - 2][col].candyType : -1;
+			if (type1 === type2 && type1 !== -1) {
+				invalidTypes.push(type1);
+			}
+		}
+		var validTypes = [];
+		for (var i = 0; i < 6; i++) {
+			if (invalidTypes.indexOf(i) === -1) {
+				validTypes.push(i);
+			}
+		}
+		return validTypes[Math.floor(Math.random() * validTypes.length)];
+	};
+	self.swapCandies = function (candy1, candy2) {
+		if (!candy1 || !candy2) return false;
+		var tempX = candy1.gridX;
+		var tempY = candy1.gridY;
+		candy1.gridX = candy2.gridX;
+		candy1.gridY = candy2.gridY;
+		candy2.gridX = tempX;
+		candy2.gridY = tempY;
+		self.grid[candy1.gridY][candy1.gridX] = candy1;
+		self.grid[candy2.gridY][candy2.gridX] = candy2;
+		// Animate swap
+		candy1.isAnimating = true;
+		candy2.isAnimating = true;
+		tween(candy1, {
+			x: candy1.gridX * self.cellSize,
+			y: candy1.gridY * self.cellSize
+		}, {
+			duration: 200,
+			onFinish: function onFinish() {
+				candy1.isAnimating = false;
+			}
+		});
+		tween(candy2, {
+			x: candy2.gridX * self.cellSize,
+			y: candy2.gridY * self.cellSize
+		}, {
+			duration: 200,
+			onFinish: function onFinish() {
+				candy2.isAnimating = false;
+				self.checkMatches();
+			}
+		});
+		return true;
+	};
+	self.checkMatches = function () {
+		var matches = [];
+		var visited = [];
+		// Initialize visited array
+		for (var row = 0; row < self.gridSize; row++) {
+			visited[row] = [];
+			for (var col = 0; col < self.gridSize; col++) {
+				visited[row][col] = false;
+			}
+		}
+		// Check horizontal matches
+		for (var row = 0; row < self.gridSize; row++) {
+			var count = 1;
+			var currentType = self.grid[row][0] ? self.grid[row][0].candyType : -1;
+			for (var col = 1; col < self.gridSize; col++) {
+				var cellType = self.grid[row][col] ? self.grid[row][col].candyType : -1;
+				if (cellType === currentType && currentType !== -1) {
+					count++;
+				} else {
+					if (count >= 3) {
+						for (var i = col - count; i < col; i++) {
+							if (!visited[row][i]) {
+								matches.push({
+									row: row,
+									col: i
+								});
+								visited[row][i] = true;
+							}
+						}
+					}
+					count = 1;
+					currentType = cellType;
+				}
+			}
+			if (count >= 3) {
+				for (var i = self.gridSize - count; i < self.gridSize; i++) {
+					if (!visited[row][i]) {
+						matches.push({
+							row: row,
+							col: i
+						});
+						visited[row][i] = true;
+					}
+				}
+			}
+		}
+		// Check vertical matches
+		for (var col = 0; col < self.gridSize; col++) {
+			var count = 1;
+			var currentType = self.grid[0][col] ? self.grid[0][col].candyType : -1;
+			for (var row = 1; row < self.gridSize; row++) {
+				var cellType = self.grid[row][col] ? self.grid[row][col].candyType : -1;
+				if (cellType === currentType && currentType !== -1) {
+					count++;
+				} else {
+					if (count >= 3) {
+						for (var i = row - count; i < row; i++) {
+							if (!visited[i][col]) {
+								matches.push({
+									row: i,
+									col: col
+								});
+								visited[i][col] = true;
+							}
+						}
+					}
+					count = 1;
+					currentType = cellType;
+				}
+			}
+			if (count >= 3) {
+				for (var i = self.gridSize - count; i < self.gridSize; i++) {
+					if (!visited[i][col]) {
+						matches.push({
+							row: i,
+							col: col
+						});
+						visited[i][col] = true;
+					}
+				}
+			}
+		}
+		if (matches.length > 0) {
+			self.removeMatches(matches);
+			return true;
+		}
+		return false;
+	};
+	self.removeMatches = function (matches) {
+		var points = 0;
+		for (var i = 0; i < matches.length; i++) {
+			var match = matches[i];
+			var candy = self.grid[match.row][match.col];
+			if (candy) {
+				points += 10;
+				// Check for special candy creation
+				var matchLength = self.getMatchLength(match.row, match.col, candy.candyType);
+				if (matchLength >= 5) {
+					// Create rainbow candy
+					candy.makeSpecial('rainbow');
+					continue;
+				} else if (matchLength >= 4) {
+					// Create bomb candy
+					candy.makeSpecial('bomb');
+					continue;
+				}
+				self.removeChild(candy);
+				self.grid[match.row][match.col] = null;
+			}
+		}
+		LK.setScore(LK.getScore() + points);
+		scoreText.setText(LK.getScore() + ' / ' + targetScore);
+		LK.getSound('match').play();
+		// Apply gravity and cascade
+		LK.setTimeout(function () {
+			self.applyGravity();
+		}, 100);
+	};
+	self.getMatchLength = function (row, col, candyType) {
+		var length = 1;
+		// Count horizontal
+		var left = col - 1;
+		while (left >= 0 && self.grid[row][left] && self.grid[row][left].candyType === candyType) {
+			length++;
+			left--;
+		}
+		var right = col + 1;
+		while (right < self.gridSize && self.grid[row][right] && self.grid[row][right].candyType === candyType) {
+			length++;
+			right++;
+		}
+		return length;
+	};
+	self.applyGravity = function () {
+		var moved = false;
+		for (var col = 0; col < self.gridSize; col++) {
+			for (var row = self.gridSize - 1; row >= 0; row--) {
+				if (!self.grid[row][col]) {
+					// Find candy above to fall down
+					for (var aboveRow = row - 1; aboveRow >= 0; aboveRow--) {
+						if (self.grid[aboveRow][col]) {
+							var candy = self.grid[aboveRow][col];
+							self.grid[row][col] = candy;
+							self.grid[aboveRow][col] = null;
+							candy.gridY = row;
+							candy.isAnimating = true;
+							moved = true;
+							tween(candy, {
+								y: row * self.cellSize
+							}, {
+								duration: 300,
+								easing: tween.easeOut,
+								onFinish: function onFinish() {
+									candy.isAnimating = false;
+								}
+							});
+							break;
+						}
+					}
+				}
+			}
+		}
+		if (moved) {
+			LK.getSound('cascade').play();
+		}
+		// Fill empty spaces and check for new matches
+		LK.setTimeout(function () {
+			self.fillGrid();
+			LK.setTimeout(function () {
+				if (!self.checkMatches()) {
+					isProcessingMatches = false;
+				}
+			}, 100);
+		}, 350);
+	};
+	self.isAdjacent = function (candy1, candy2) {
+		var dx = Math.abs(candy1.gridX - candy2.gridX);
+		var dy = Math.abs(candy1.gridY - candy2.gridY);
+		return dx === 1 && dy === 0 || dx === 0 && dy === 1;
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x8B4513
+});
+
+/**** 
+* Game Code
+****/ 
+var gameGrid;
+var selectedCandy = null;
+var movesLeft = 20;
+var targetScore = 1000;
+var currentLevel = 1;
+var isProcessingMatches = false;
+// UI Elements
+var scoreText = new Text2('0 / 1000', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+scoreText.anchor.set(0.5, 0);
+LK.gui.top.addChild(scoreText);
+var movesText = new Text2('Moves: 20', {
+	size: 50,
+	fill: 0xFFFFFF
+});
+movesText.anchor.set(0, 0);
+movesText.x = 50;
+movesText.y = 100;
+LK.gui.topLeft.addChild(movesText);
+var levelText = new Text2('Level 1', {
+	size: 50,
+	fill: 0xFFFFFF
+});
+levelText.anchor.set(1, 0);
+levelText.x = -50;
+levelText.y = 100;
+LK.gui.topRight.addChild(levelText);
+// Initialize game grid
+gameGrid = new GameGrid();
+gameGrid.init();
+// Center the grid
+var gridWidth = gameGrid.gridSize * gameGrid.cellSize;
+var gridHeight = gameGrid.gridSize * gameGrid.cellSize;
+gameGrid.x = (2048 - gridWidth) / 2;
+gameGrid.y = (2732 - gridHeight) / 2 + 100;
+game.addChild(gameGrid);
+function handleCandyClick(candy) {
+	if (isProcessingMatches || movesLeft <= 0) return;
+	if (!selectedCandy) {
+		selectedCandy = candy;
+		candy.setSelected(true);
+	} else if (selectedCandy === candy) {
+		selectedCandy.setSelected(false);
+		selectedCandy = null;
+	} else if (gameGrid.isAdjacent(selectedCandy, candy)) {
+		// Valid swap
+		selectedCandy.setSelected(false);
+		var oldGrid1 = {
+			x: selectedCandy.gridX,
+			y: selectedCandy.gridY
+		};
+		var oldGrid2 = {
+			x: candy.gridX,
+			y: candy.gridY
+		};
+		if (gameGrid.swapCandies(selectedCandy, candy)) {
+			movesLeft--;
+			movesText.setText('Moves: ' + movesLeft);
+			isProcessingMatches = true;
+			// Check if swap creates matches, if not, swap back
+			LK.setTimeout(function () {
+				if (!gameGrid.checkMatches()) {
+					// Swap back
+					selectedCandy.gridX = oldGrid1.x;
+					selectedCandy.gridY = oldGrid1.y;
+					candy.gridX = oldGrid2.x;
+					candy.gridY = oldGrid2.y;
+					gameGrid.grid[selectedCandy.gridY][selectedCandy.gridX] = selectedCandy;
+					gameGrid.grid[candy.gridY][candy.gridX] = candy;
+					tween(selectedCandy, {
+						x: selectedCandy.gridX * gameGrid.cellSize,
+						y: selectedCandy.gridY * gameGrid.cellSize
+					}, {
+						duration: 200
+					});
+					tween(candy, {
+						x: candy.gridX * gameGrid.cellSize,
+						y: candy.gridY * gameGrid.cellSize
+					}, {
+						duration: 200
+					});
+					movesLeft++;
+					movesText.setText('Moves: ' + movesLeft);
+					isProcessingMatches = false;
+				}
+			}, 250);
+		}
+		selectedCandy = null;
+	} else {
+		selectedCandy.setSelected(false);
+		selectedCandy = candy;
+		candy.setSelected(true);
+	}
+}
+game.update = function () {
+	// Check win condition
+	if (LK.getScore() >= targetScore) {
+		currentLevel++;
+		targetScore += 500;
+		movesLeft = 20;
+		levelText.setText('Level ' + currentLevel);
+		scoreText.setText(LK.getScore() + ' / ' + targetScore);
+		movesText.setText('Moves: ' + movesLeft);
+		// Reset grid for next level
+		for (var row = 0; row < gameGrid.gridSize; row++) {
+			for (var col = 0; col < gameGrid.gridSize; col++) {
+				if (gameGrid.grid[row][col]) {
+					gameGrid.removeChild(gameGrid.grid[row][col]);
+					gameGrid.grid[row][col] = null;
+				}
+			}
+		}
+		gameGrid.fillGrid();
+	}
+	// Check lose condition
+	if (movesLeft <= 0 && LK.getScore() < targetScore && !isProcessingMatches) {
+		LK.showGameOver();
+	}
+};
\ No newline at end of file
Showing 1 to 5 of 5
1

Used plugins

@upit/tween
Home
Discover
Play
Profile