Play
:quality(85)/https:%2F%2Fcdn.frvr.ai/685c1b7607eab10c2d8e4117.png)
:quality(85)/https:%2F%2Fcdn.frvr.ai/685c1b8bc13ea649fe5189c1.png)
#cars
#vehicles
#casual
##Color #Crush #Rush #Match
##Color #Crush #Match #Rush
Creation History
User prompt
Please add total 10 levels and finish screen after 10000 points
User prompt
when player moves correctly play music one time and again moves correctly play music one time and goes
User prompt
Why music play second time when i do second match
User prompt
Please play the music when swap is okay please play only one time
User prompt
Music only one time please
User prompt
Please only one time
User prompt
Please add this song the game please play always
User prompt
When match is okay please play the sound
User prompt
Please add this song match sound
User prompt
Please add sound the match
User prompt
Please show suggestion move when player doesn't play 5 seconds ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Please add suggestion move ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Please swap easyly it is difficult
User prompt
please add animation to match cars ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Why ı can't match 3 color please fix that shit
User prompt
I can't move when it is 3 combonation please fix that
User prompt
If 4 combonation this is bonus point if 5 combonation this is more bonus point
User prompt
if there is 3 combonation will be okay but if no 3 combonation this move isn't okay. Take back
User prompt
Please add cars to box
Code edit (1 edits merged)
Please save this source code
User prompt
Car Crush Rush
Initial prompt
Please create like candy crush but no sugar yes car
/****
* Plugins
****/
var tween = LK.import("@upit/tween.v1");
/****
* Classes
****/
var Car = Container.expand(function (carType) {
var self = Container.call(this);
self.carType = carType || 'redCar';
self.gridX = 0;
self.gridY = 0;
self.isAnimating = false;
self.isMatched = false;
var carGraphics = self.attachAsset(self.carType, {
anchorX: 0.5,
anchorY: 0.5
});
self.down = function (x, y, obj) {
if (self.isAnimating || gameState !== 'playing' || gameCompleted) return;
selectedCar = self;
startDragX = x;
startDragY = y;
clearSuggestion();
startSuggestionTimer();
};
self.setGridPosition = function (gridX, gridY) {
self.gridX = gridX;
self.gridY = gridY;
self.x = gridOffsetX + gridX * CELL_SIZE + CELL_SIZE / 2;
self.y = gridOffsetY + gridY * CELL_SIZE + CELL_SIZE / 2;
};
self.animateToPosition = function (targetX, targetY, duration, onComplete) {
self.isAnimating = true;
tween(self, {
x: targetX,
y: targetY
}, {
duration: duration || 300,
easing: tween.easeOut,
onFinish: function onFinish() {
self.isAnimating = false;
if (onComplete) onComplete();
}
});
};
self.destroy = function () {
if (self.parent) {
self.parent.removeChild(self);
}
};
return self;
});
/****
* Initialize Game
****/
var game = new LK.Game({
backgroundColor: 0x222222
});
/****
* Game Code
****/
// Game constants
var GRID_SIZE = 8;
var CELL_SIZE = 200;
var gridOffsetX = (2048 - GRID_SIZE * CELL_SIZE) / 2;
var gridOffsetY = (2732 - GRID_SIZE * CELL_SIZE) / 2;
// Car types
var carTypes = ['redCar', 'blueCar', 'greenCar', 'yellowCar', 'purpleCar', 'orangeCar'];
// Game state
var grid = [];
var cars = [];
var selectedCar = null;
var startDragX = 0;
var startDragY = 0;
var gameState = 'playing'; // 'playing', 'animating', 'checking'
var score = 0;
var level = 1;
var targetScore = 1000;
var maxLevel = 10;
var gameCompleted = false;
var suggestedCars = [];
var suggestionTimer = null;
var musicPlayed = false;
// UI Elements
var scoreText = new Text2('Score: 0', {
size: 80,
fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
scoreText.y = 100;
var levelText = new Text2('Level: 1', {
size: 60,
fill: 0xFFFFFF
});
levelText.anchor.set(0, 0);
LK.gui.topLeft.addChild(levelText);
levelText.x = 150;
levelText.y = 50;
var targetText = new Text2('Target: 1000', {
size: 60,
fill: 0xFFFFFF
});
targetText.anchor.set(1, 0);
LK.gui.topRight.addChild(targetText);
targetText.y = 50;
// Create grid background
var gridBg = game.addChild(LK.getAsset('gridBackground', {
anchorX: 0.5,
anchorY: 0.5
}));
gridBg.x = 2048 / 2;
gridBg.y = 2732 / 2;
// Create cell backgrounds
for (var i = 0; i < GRID_SIZE; i++) {
for (var j = 0; j < GRID_SIZE; j++) {
var cellBg = game.addChild(LK.getAsset('cellBackground', {
anchorX: 0.5,
anchorY: 0.5
}));
cellBg.x = gridOffsetX + i * CELL_SIZE + CELL_SIZE / 2;
cellBg.y = gridOffsetY + j * CELL_SIZE + CELL_SIZE / 2;
}
}
// Initialize grid
function initializeGrid() {
grid = [];
cars = [];
for (var y = 0; y < GRID_SIZE; y++) {
grid[y] = [];
for (var x = 0; x < GRID_SIZE; x++) {
var carType = getRandomCarType();
var car = new Car(carType);
car.setGridPosition(x, y);
grid[y][x] = car;
cars.push(car);
game.addChild(car);
}
}
// Remove initial matches
while (findMatches().length > 0) {
regenerateGrid();
}
}
function getRandomCarType() {
return carTypes[Math.floor(Math.random() * carTypes.length)];
}
function regenerateGrid() {
for (var y = 0; y < GRID_SIZE; y++) {
for (var x = 0; x < GRID_SIZE; x++) {
if (grid[y][x]) {
grid[y][x].carType = getRandomCarType();
grid[y][x].removeChild(grid[y][x].children[0]);
var newGraphics = grid[y][x].attachAsset(grid[y][x].carType, {
anchorX: 0.5,
anchorY: 0.5
});
}
}
}
}
function isValidPosition(x, y) {
return x >= 0 && x < GRID_SIZE && y >= 0 && y < GRID_SIZE;
}
function swapCars(car1, car2) {
if (!car1 || !car2) return false;
var tempX = car1.gridX;
var tempY = car1.gridY;
var originalCar1X = car1.gridX;
var originalCar1Y = car1.gridY;
var originalCar2X = car2.gridX;
var originalCar2Y = car2.gridY;
// Temporarily update grid to test for matches
grid[car1.gridY][car1.gridX] = car2;
grid[car2.gridY][car2.gridX] = car1;
// Temporarily update car positions for match checking
car2.gridX = tempX;
car2.gridY = tempY;
car1.gridX = originalCar2X;
car1.gridY = originalCar2Y;
// Check if this swap creates any matches
var matches = findMatches();
var hasMatches = matches.length > 0;
if (!hasMatches) {
// Revert the temporary changes - no matches found, invalid move
grid[originalCar1Y][originalCar1X] = car1;
grid[originalCar2Y][originalCar2X] = car2;
car1.gridX = originalCar1X;
car1.gridY = originalCar1Y;
car2.gridX = originalCar2X;
car2.gridY = originalCar2Y;
return false;
}
// Animate to new positions
gameState = 'animating';
var animationsComplete = 0;
car1.animateToPosition(gridOffsetX + car1.gridX * CELL_SIZE + CELL_SIZE / 2, gridOffsetY + car1.gridY * CELL_SIZE + CELL_SIZE / 2, 300, function () {
animationsComplete++;
if (animationsComplete === 2) {
checkForMatches();
}
});
car2.animateToPosition(gridOffsetX + car2.gridX * CELL_SIZE + CELL_SIZE / 2, gridOffsetY + car2.gridY * CELL_SIZE + CELL_SIZE / 2, 300, function () {
animationsComplete++;
if (animationsComplete === 2) {
checkForMatches();
}
});
LK.playMusic('song', {
loop: false
});
return true;
}
function findMatches() {
var matches = [];
var matchGroups = []; // Track individual match groups for bonus scoring
// Check horizontal matches
for (var y = 0; y < GRID_SIZE; y++) {
var count = 1;
var currentType = grid[y][0] ? grid[y][0].carType : null;
for (var x = 1; x < GRID_SIZE; x++) {
if (grid[y][x] && currentType && grid[y][x].carType === currentType) {
count++;
} else {
if (count >= 3 && currentType) {
var matchGroup = {
count: count,
positions: []
};
for (var i = x - count; i < x; i++) {
var matchPos = {
x: i,
y: y
};
matches.push(matchPos);
matchGroup.positions.push(matchPos);
}
matchGroups.push(matchGroup);
}
currentType = grid[y][x] ? grid[y][x].carType : null;
count = 1;
}
}
if (count >= 3 && currentType) {
var matchGroup = {
count: count,
positions: []
};
for (var i = GRID_SIZE - count; i < GRID_SIZE; i++) {
var matchPos = {
x: i,
y: y
};
matches.push(matchPos);
matchGroup.positions.push(matchPos);
}
matchGroups.push(matchGroup);
}
}
// Check vertical matches
for (var x = 0; x < GRID_SIZE; x++) {
var count = 1;
var currentType = grid[0][x] ? grid[0][x].carType : null;
for (var y = 1; y < GRID_SIZE; y++) {
if (grid[y][x] && currentType && grid[y][x].carType === currentType) {
count++;
} else {
if (count >= 3 && currentType) {
var matchGroup = {
count: count,
positions: []
};
for (var i = y - count; i < y; i++) {
var matchPos = {
x: x,
y: i
};
matches.push(matchPos);
matchGroup.positions.push(matchPos);
}
matchGroups.push(matchGroup);
}
currentType = grid[y][x] ? grid[y][x].carType : null;
count = 1;
}
}
if (count >= 3 && currentType) {
var matchGroup = {
count: count,
positions: []
};
for (var i = GRID_SIZE - count; i < GRID_SIZE; i++) {
var matchPos = {
x: x,
y: i
};
matches.push(matchPos);
matchGroup.positions.push(matchPos);
}
matchGroups.push(matchGroup);
}
}
// Store match groups for bonus scoring
matches.matchGroups = matchGroups;
return matches;
}
function removeMatches(matches) {
var uniqueMatches = [];
// Remove duplicates
for (var i = 0; i < matches.length; i++) {
var isUnique = true;
for (var j = 0; j < uniqueMatches.length; j++) {
if (matches[i].x === uniqueMatches[j].x && matches[i].y === uniqueMatches[j].y) {
isUnique = false;
break;
}
}
if (isUnique) {
uniqueMatches.push(matches[i]);
}
}
// Animate matched cars before removing them
var animationsCompleted = 0;
var totalAnimations = uniqueMatches.length;
for (var i = 0; i < uniqueMatches.length; i++) {
var match = uniqueMatches[i];
if (grid[match.y][match.x]) {
var car = grid[match.y][match.x];
car.isMatched = true;
// Scale up and fade out animation
tween(car, {
scaleX: 1.3,
scaleY: 1.3,
alpha: 0
}, {
duration: 300,
easing: tween.easeOut,
onFinish: function onFinish() {
animationsCompleted++;
if (animationsCompleted === totalAnimations) {
// All animations complete, now actually remove the cars
for (var k = 0; k < uniqueMatches.length; k++) {
var removeMatch = uniqueMatches[k];
if (grid[removeMatch.y][removeMatch.x]) {
var carToRemove = grid[removeMatch.y][removeMatch.x];
carToRemove.destroy();
grid[removeMatch.y][removeMatch.x] = null;
// Remove from cars array
for (var j = cars.length - 1; j >= 0; j--) {
if (cars[j] === carToRemove) {
cars.splice(j, 1);
break;
}
}
}
}
// Continue with dropping and filling after all cars are removed
LK.setTimeout(function () {
if (dropCars()) {
LK.setTimeout(function () {
fillEmptySpaces();
LK.setTimeout(function () {
checkForMatches();
}, 400);
}, 300);
} else {
fillEmptySpaces();
LK.setTimeout(function () {
checkForMatches();
}, 400);
}
}, 100);
}
}
});
}
}
// Calculate score with bonus points for 4+ and 5+ combinations
var totalScore = 0;
var basePoints = 10;
if (matches.matchGroups) {
for (var i = 0; i < matches.matchGroups.length; i++) {
var matchGroup = matches.matchGroups[i];
var groupScore = matchGroup.count * basePoints;
// Apply bonus multipliers
if (matchGroup.count >= 5) {
groupScore *= 3; // Triple points for 5+ matches
} else if (matchGroup.count >= 4) {
groupScore *= 2; // Double points for 4+ matches
}
totalScore += groupScore;
}
} else {
// Fallback to old scoring if no match groups
totalScore = uniqueMatches.length * basePoints;
}
score += totalScore;
scoreText.setText('Score: ' + score);
if (uniqueMatches.length > 0) {
LK.getSound('match').play();
}
return uniqueMatches.length;
}
function dropCars() {
var moved = false;
for (var x = 0; x < GRID_SIZE; x++) {
// Find empty spaces from bottom up
for (var y = GRID_SIZE - 1; y >= 0; y--) {
if (!grid[y][x]) {
// Find the next car above this empty space
for (var aboveY = y - 1; aboveY >= 0; aboveY--) {
if (grid[aboveY][x]) {
var car = grid[aboveY][x];
grid[y][x] = car;
grid[aboveY][x] = null;
car.gridY = y;
car.animateToPosition(gridOffsetX + x * CELL_SIZE + CELL_SIZE / 2, gridOffsetY + y * CELL_SIZE + CELL_SIZE / 2, 200);
moved = true;
break;
}
}
}
}
}
return moved;
}
function fillEmptySpaces() {
var added = false;
for (var x = 0; x < GRID_SIZE; x++) {
for (var y = 0; y < GRID_SIZE; y++) {
if (!grid[y][x]) {
var carType = getRandomCarType();
var car = new Car(carType);
car.setGridPosition(x, y);
car.y = gridOffsetY - CELL_SIZE;
grid[y][x] = car;
cars.push(car);
game.addChild(car);
car.animateToPosition(gridOffsetX + x * CELL_SIZE + CELL_SIZE / 2, gridOffsetY + y * CELL_SIZE + CELL_SIZE / 2, 300);
added = true;
}
}
}
return added;
}
function checkForMatches() {
var matches = findMatches();
if (matches.length > 0) {
clearSuggestion();
removeMatches(matches);
} else {
gameState = 'playing';
checkLevelComplete();
startSuggestionTimer();
}
}
function checkLevelComplete() {
if (score >= targetScore) {
if (level >= maxLevel || score >= 10000) {
// Game completed - show finish screen
gameCompleted = true;
gameState = 'completed';
LK.effects.flashScreen(0x00ff00, 2000);
LK.setTimeout(function () {
LK.showYouWin();
}, 2000);
return;
}
level++;
targetScore = level * 1000;
levelText.setText('Level: ' + level);
targetText.setText('Target: ' + targetScore);
// Flash screen green for level complete
LK.effects.flashScreen(0x00ff00, 1000);
}
}
function findPossibleMoves() {
var possibleMoves = [];
for (var y = 0; y < GRID_SIZE; y++) {
for (var x = 0; x < GRID_SIZE; x++) {
if (!grid[y][x]) continue;
// Check right neighbor
if (x < GRID_SIZE - 1 && grid[y][x + 1]) {
if (wouldCreateMatch(x, y, x + 1, y)) {
possibleMoves.push({
car1: {
x: x,
y: y
},
car2: {
x: x + 1,
y: y
}
});
}
}
// Check down neighbor
if (y < GRID_SIZE - 1 && grid[y + 1][x]) {
if (wouldCreateMatch(x, y, x, y + 1)) {
possibleMoves.push({
car1: {
x: x,
y: y
},
car2: {
x: x,
y: y + 1
}
});
}
}
}
}
return possibleMoves;
}
function wouldCreateMatch(x1, y1, x2, y2) {
if (!grid[y1][x1] || !grid[y2][x2]) return false;
// Temporarily swap the cars
var car1 = grid[y1][x1];
var car2 = grid[y2][x2];
grid[y1][x1] = car2;
grid[y2][x2] = car1;
car2.gridX = x1;
car2.gridY = y1;
car1.gridX = x2;
car1.gridY = y2;
// Check for matches
var matches = findMatches();
var hasMatches = matches.length > 0;
// Restore original positions
grid[y1][x1] = car1;
grid[y2][x2] = car2;
car1.gridX = x1;
car1.gridY = y1;
car2.gridX = x2;
car2.gridY = y2;
return hasMatches;
}
function showSuggestion() {
clearSuggestion();
if (gameState !== 'playing') return;
var possibleMoves = findPossibleMoves();
if (possibleMoves.length > 0) {
// Show a random possible move
var randomMove = possibleMoves[Math.floor(Math.random() * possibleMoves.length)];
var car1 = grid[randomMove.car1.y][randomMove.car1.x];
var car2 = grid[randomMove.car2.y][randomMove.car2.x];
if (car1 && car2) {
suggestedCars = [car1, car2];
// Add pulsing glow effect to suggested cars
tween(car1, {
alpha: 0.6
}, {
duration: 800,
easing: tween.easeInOut,
onFinish: function onFinish() {
if (suggestedCars.indexOf(car1) !== -1) {
tween(car1, {
alpha: 1
}, {
duration: 800,
easing: tween.easeInOut,
onFinish: function onFinish() {
if (suggestedCars.indexOf(car1) !== -1) {
showSuggestion(); // Continue pulsing
}
}
});
}
}
});
tween(car2, {
alpha: 0.6
}, {
duration: 800,
easing: tween.easeInOut,
onFinish: function onFinish() {
if (suggestedCars.indexOf(car2) !== -1) {
tween(car2, {
alpha: 1
}, {
duration: 800,
easing: tween.easeInOut
});
}
}
});
}
}
}
function clearSuggestion() {
for (var i = 0; i < suggestedCars.length; i++) {
var car = suggestedCars[i];
if (car && !car.isMatched) {
tween.stop(car, {
alpha: true
});
car.alpha = 1;
}
}
suggestedCars = [];
}
function startSuggestionTimer() {
if (suggestionTimer) {
LK.clearTimeout(suggestionTimer);
}
if (!gameCompleted && gameState === 'playing') {
suggestionTimer = LK.setTimeout(function () {
showSuggestion();
}, 5000); // Show suggestion after 5 seconds of inactivity
}
}
// Game input handling
game.move = function (x, y, obj) {
if (!selectedCar || gameState !== 'playing' || gameCompleted) return;
var deltaX = x - startDragX;
var deltaY = y - startDragY;
var threshold = 30;
if (Math.abs(deltaX) > threshold || Math.abs(deltaY) > threshold) {
var targetX = selectedCar.gridX;
var targetY = selectedCar.gridY;
if (Math.abs(deltaX) > Math.abs(deltaY)) {
targetX += deltaX > 0 ? 1 : -1;
} else {
targetY += deltaY > 0 ? 1 : -1;
}
if (isValidPosition(targetX, targetY)) {
var targetCar = grid[targetY][targetX];
if (targetCar) {
clearSuggestion();
if (swapCars(selectedCar, targetCar)) {
startSuggestionTimer();
} else {
startSuggestionTimer();
}
}
}
selectedCar = null;
}
};
game.up = function (x, y, obj) {
selectedCar = null;
if (gameState === 'playing') {
startSuggestionTimer();
}
};
// Initialize the game
initializeGrid();
startSuggestionTimer();
// Music plays on each successful swap - no initialization needed here ===================================================================
--- original.js
+++ change.js
@@ -17,9 +17,9 @@
anchorX: 0.5,
anchorY: 0.5
});
self.down = function (x, y, obj) {
- if (self.isAnimating || gameState !== 'playing') return;
+ if (self.isAnimating || gameState !== 'playing' || gameCompleted) return;
selectedCar = self;
startDragX = x;
startDragY = y;
clearSuggestion();
@@ -79,8 +79,10 @@
var gameState = 'playing'; // 'playing', 'animating', 'checking'
var score = 0;
var level = 1;
var targetScore = 1000;
+var maxLevel = 10;
+var gameCompleted = false;
var suggestedCars = [];
var suggestionTimer = null;
var musicPlayed = false;
// UI Elements
@@ -457,8 +459,18 @@
}
}
function checkLevelComplete() {
if (score >= targetScore) {
+ if (level >= maxLevel || score >= 10000) {
+ // Game completed - show finish screen
+ gameCompleted = true;
+ gameState = 'completed';
+ LK.effects.flashScreen(0x00ff00, 2000);
+ LK.setTimeout(function () {
+ LK.showYouWin();
+ }, 2000);
+ return;
+ }
level++;
targetScore = level * 1000;
levelText.setText('Level: ' + level);
targetText.setText('Target: ' + targetScore);
@@ -595,15 +607,17 @@
function startSuggestionTimer() {
if (suggestionTimer) {
LK.clearTimeout(suggestionTimer);
}
- suggestionTimer = LK.setTimeout(function () {
- showSuggestion();
- }, 5000); // Show suggestion after 5 seconds of inactivity
+ if (!gameCompleted && gameState === 'playing') {
+ suggestionTimer = LK.setTimeout(function () {
+ showSuggestion();
+ }, 5000); // Show suggestion after 5 seconds of inactivity
+ }
}
// Game input handling
game.move = function (x, y, obj) {
- if (!selectedCar || gameState !== 'playing') return;
+ if (!selectedCar || gameState !== 'playing' || gameCompleted) return;
var deltaX = x - startDragX;
var deltaY = y - startDragY;
var threshold = 30;
if (Math.abs(deltaX) > threshold || Math.abs(deltaY) > threshold) {
Showing 1 to 22 of 22
Sounds & Music
Used plugins
@upit/tween
