Play
:quality(85)/https://cdn.frvr.ai/67cc7facb2f53263695b03c3.png)
:quality(85)/https://cdn.upit.com/8hhy3om9wqaxchoiwfvychmy.png)
:quality(85)/https://cdn.frvr.ai/67ca27013b19280b799c6364.png)
#breakout
#idle
#UpitIdleGameContest
#UpitIdleContest
#idelbreakout
Creation History
Code edit (2 edits merged)
Please save this source code
User prompt
play bounce sound when ball bounces
Code edit (3 edits merged)
Please save this source code
User prompt
change creatUpgradeButton position, have them have 10 pixels between each other
Code edit (1 edits merged)
Please save this source code
User prompt
add a little more space between the buttons for the power ups int he bottom of the screen
User prompt
add a little more space between the buttons for the power ups int he bottom of the screen
User prompt
upgrade buttons should have a little moroe space between them
User prompt
powerups should use powerup asset
User prompt
Powerup are using an asset for their background button. create a new asset to be used by all of them. should be powerupbutton
User prompt
create a new button for powerup buttons
User prompt
increase the size parameter of the buttons for the upgrades to be the same as the buy balls ones
User prompt
rename buyball50 to button
User prompt
upgrade buttons and text should be the same size as ball purchase buttons, and have the same space between each ther
Code edit (1 edits merged)
Please save this source code
User prompt
normal ball should start unlocked
User prompt
move points 50 pixels to the right
User prompt
move points and level 200 pixles ot the right
User prompt
sorry I meant to the right
User prompt
move level 100 pixels to the left
User prompt
move level below points
User prompt
move points to 200 pixels to the right
Code edit (1 edits merged)
Please save this source code
User prompt
use a new asset for particle effect, not splash ball
User prompt
lets add somoe particle effect when a block is destroyed
/****
* Plugins
****/
var storage = LK.import("@upit/storage.v1");
/****
* Classes
****/
var Ball = Container.expand(function () {
var self = Container.call(this);
var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'normal';
var asset = type === 'splash' ? 'splashBall' : type === 'sniper' ? 'sniperBall' : type === 'scatter' ? 'scatterBall' : type === 'smallScatter' ? 'smallScatter' : 'ball';
var ballGraphics = self.attachAsset(asset, {
anchorX: 0.5,
anchorY: 0.5
});
self.type = type;
self.speed = type === 'splash' ? upgrades.splashSpeed : type === 'sniper' ? upgrades.sniperSpeed : type === 'scatter' ? upgrades.scatterSpeed : type === 'smallScatter' ? upgrades.scatterSpeed * 0.8 : upgrades.normalSpeed;
self.power = type === 'splash' ? upgrades.splashPower : type === 'sniper' ? upgrades.sniperPower : type === 'scatter' ? upgrades.scatterPower : type === 'smallScatter' ? Math.max(1, Math.floor(upgrades.scatterPower * 0.5)) : upgrades.normalPower;
self.direction = {
x: 1,
y: -1
};
self.update = function () {
var gridSize = levelConfig[level] ? levelConfig[level].gridSize : 200;
var stepSize = self.speed;
if (self.type === 'sniper') {
var nearestBrick = findNearestBrick(self.x, self.y);
if (nearestBrick) {
var dx = nearestBrick.x - self.x;
var dy = nearestBrick.y - self.y;
var magnitude = Math.sqrt(dx * dx + dy * dy);
self.direction.x = dx / magnitude;
self.direction.y = dy / magnitude;
}
}
var dx = self.direction.x * stepSize;
var dy = self.direction.y * stepSize;
self.x += dx;
self.y += dy;
if (self.x <= BALL_RADIUS || self.x >= GAME_WIDTH - BALL_RADIUS) {
self.direction.x *= -1;
self.x = Math.max(BALL_RADIUS, Math.min(GAME_WIDTH - BALL_RADIUS, self.x));
}
if (self.y <= BALL_RADIUS || self.y >= GAME_HEIGHT - BALL_RADIUS) {
self.direction.y *= -1;
self.y = Math.max(BALL_RADIUS, Math.min(GAME_HEIGHT - BALL_RADIUS, self.y));
}
if (!isNearBricks(self.x, self.y)) {
return;
}
var gridXMin = Math.floor((self.x - BALL_RADIUS) / gridSize);
var gridXMax = Math.floor((self.x + BALL_RADIUS) / gridSize);
var gridYMin = Math.floor((self.y - BALL_RADIUS) / gridSize);
var gridYMax = Math.floor((self.y + BALL_RADIUS) / gridSize);
var hasCollided = false;
for (var gx = gridXMin; gx <= gridXMax && !hasCollided; gx++) {
for (var gy = gridYMin; gy <= gridYMax && !hasCollided; gy++) {
var gridKey = "".concat(gx, ",").concat(gy);
var cellBricks = brickGrid[gridKey];
if (!cellBricks || cellBricks.length === 0) {
continue;
}
for (var j = cellBricks.length - 1; j >= 0; j--) {
var brick = cellBricks[j];
if (!brick || brick.health <= 0 || !self.intersects(brick)) {
continue;
}
handleBallBrickCollision(self, brick);
brick.hit(self.power);
if (self.type === 'splash' && brick.health > 0) {
applySplashDamage(brick, gridSize);
} else if (self.type === 'scatter') {
scatterOnImpact(self);
self.destroy();
balls.splice(balls.indexOf(self), 1);
hasCollided = true;
break;
}
if (brick.health <= 0) {
cellBricks.splice(j, 1);
}
hasCollided = true;
break;
}
}
}
};
});
var Brick = Container.expand(function () {
var self = Container.call(this);
var brickGraphics = self.attachAsset('brick', {
anchorX: 0.5,
anchorY: 0.5
});
self.health = 1;
self.maxHealth = 1;
self.healthText = new Text2(self.health.toString(), {
size: 50,
fill: 0xFFFFFF
});
self.healthText.anchor.set(0.5, 0.5);
self.addChild(self.healthText);
self.updateTint = function () {
var healthPercent = self.health / self.maxHealth;
var colorIndex = Math.min(Math.floor((1 - healthPercent) * LEVEL_COLORS.length), LEVEL_COLORS.length - 1);
brickGraphics.tint = LEVEL_COLORS[colorIndex];
};
self.updateTint();
self.hit = function () {
var damage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
self.health -= damage;
if (self.health <= 0) {
score += Math.max(1, Math.floor(self.maxHealth * 0.5));
scoreTxt.setText('$' + score.toString());
storage.score = score;
var brickIndex = bricks.indexOf(self);
if (brickIndex !== -1) {
bricks.splice(brickIndex, 1);
}
self.destroy();
} else {
self.healthText.setText(self.health.toString());
self.updateTint();
}
};
});
/****
* Initialize Game
****/
var game = new LK.Game({
backgroundColor: 0x3b9c9c
});
/****
* Game Code
****/
// Unused in this update
var _storage$unlockedTier, _storage$unlockedTier2, _storage$unlockedTier3, _storage$unlockedTier4;
function _toConsumableArray(r) {
return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ("string" == typeof r) {
return _arrayLikeToArray(r, a);
}
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
}
}
function _iterableToArray(r) {
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) {
return Array.from(r);
}
}
function _arrayWithoutHoles(r) {
if (Array.isArray(r)) {
return _arrayLikeToArray(r);
}
}
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) {
n[e] = r[e];
}
return n;
}
var GAME_WIDTH = 2048;
var GAME_HEIGHT = 2632;
var BALL_RADIUS = 50;
var BRICK_WIDTH = 300;
var BRICK_HEIGHT = 99;
var BALL_COST = 50;
var LEVEL_COLORS = [0xff00ff, 0x00ffcc, 0xccff00, 0xff6600, 0x66ffff, 0xff3366, 0xffcc00, 0x9966ff, 0x33cc33, 0xff0000];
var levelConfig = {
1: {
totalBricks: 30,
hitpoints: 1,
gridSize: 400,
pattern: 'grid'
},
2: {
totalBricks: 50,
hitpoints: 2,
gridSize: 360,
pattern: 'staggered'
},
3: {
totalBricks: 70,
hitpoints: 3,
gridSize: 320,
pattern: 'clustered'
},
4: {
totalBricks: 90,
hitpoints: 4,
gridSize: 280,
pattern: 'diagonal'
},
5: {
totalBricks: 110,
hitpoints: 5,
gridSize: 240,
pattern: 'sparse'
}
};
var upgrades = {
normalSpeed: 1,
normalPower: 1,
splashSpeed: 1,
splashPower: 1,
sniperSpeed: 1.5,
sniperPower: 2,
scatterSpeed: 1,
scatterPower: 1,
clickDamage: 1,
normalSpeedCost: 50,
normalPowerCost: 75,
splashSpeedCost: 50,
splashPowerCost: 75,
sniperSpeedCost: 75,
sniperPowerCost: 100,
scatterSpeedCost: 50,
scatterPowerCost: 75,
clickCost: 25,
splashBallCost: 100,
sniperBallCost: 150,
scatterBallCost: 125
};
var balls = [];
var bricks = [];
var brickGrid = {};
var score = storage.score || 0;
var level = storage.level || 1;
var brickGridBounds = null;
var unlockedTiers = {
normal: ((_storage$unlockedTier = storage.unlockedTiers) === null || _storage$unlockedTier === void 0 ? void 0 : _storage$unlockedTier.normal) || true,
splash: ((_storage$unlockedTier2 = storage.unlockedTiers) === null || _storage$unlockedTier2 === void 0 ? void 0 : _storage$unlockedTier2.splash) || false,
sniper: ((_storage$unlockedTier3 = storage.unlockedTiers) === null || _storage$unlockedTier3 === void 0 ? void 0 : _storage$unlockedTier3.sniper) || false,
scatter: ((_storage$unlockedTier4 = storage.unlockedTiers) === null || _storage$unlockedTier4 === void 0 ? void 0 : _storage$unlockedTier4.scatter) || false
};
function clearLocalStorage() {
storage.score = 0;
storage.level = 1;
storage.unlockedTiers = {
normal: true,
splash: false,
sniper: false,
scatter: false
};
score = 0;
level = 1;
unlockedTiers = {
normal: true,
splash: false,
sniper: false,
scatter: false
};
scoreTxt.setText('$' + score.toString());
levelTxt.setText('Level: ' + level);
updateButtonStates();
}
// HUD Setup
var hud = new Container();
LK.gui.top.addChild(hud);
var scoreTxt = new Text2('0', {
size: 60,
fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.3, 0);
scoreTxt.x += 450;
hud.addChild(scoreTxt);
var levelTxt = new Text2('Level: ' + level, {
size: 60,
fill: 0xFFFFFF
});
levelTxt.anchor.set(1, 0);
levelTxt.x = scoreTxt.x + 100;
levelTxt.y = scoreTxt.height + 10;
hud.addChild(levelTxt);
var ballButtons = {};
function createBallButton(type, x, cost, asset, prevTier) {
var button = LK.getAsset('button', {
size: 80,
fill: 0xFFFFFF,
anchorX: 0.5,
anchorY: 0,
y: 0,
x: x
});
var costText = new Text2('$' + cost, {
size: 50,
fill: 0xFFFFFF
});
costText.anchor.set(0.5, 0);
costText.y = 100;
button.addChild(costText);
button.addChild(button.attachAsset(asset, {
anchorX: 0.5,
anchorY: -0.5,
scaleX: 0.5,
scaleY: 0.5
}));
button.down = function () {
if (!unlockedTiers[type] || score < cost) {
return;
}
score -= cost;
scoreTxt.setText('$' + score.toString());
createBall(type);
if (!unlockedTiers[type]) {
unlockedTiers[type] = true;
storage.unlockedTiers = unlockedTiers;
updateButtonStates();
}
};
button.updateState = function () {
var isEnabled = (prevTier ? unlockedTiers[prevTier] : true) && score >= cost;
button.tint = isEnabled ? 0xFFFFFF : 0x666666;
button.interactive = isEnabled;
};
hud.addChild(button);
ballButtons[type] = button;
}
createBallButton('normal', -400, BALL_COST, 'ball', null);
createBallButton('splash', -280, upgrades.splashBallCost, 'splashBall', 'normal');
createBallButton('sniper', -160, upgrades.sniperBallCost, 'sniperBall', 'splash');
createBallButton('scatter', -40, upgrades.scatterBallCost, 'scatterBall', 'sniper');
var clearStorageButton = LK.getAsset('button', {
size: 80,
fill: 0xFFFFFF,
anchorX: 0.5,
anchorY: 0,
x: scoreTxt.width + 200,
y: 0
});
var clearStorageText = new Text2('Reset', {
size: 50,
fill: 0xFFFFFF
});
clearStorageText.anchor.set(0.5, 0);
clearStorageText.y = 100;
clearStorageButton.addChild(clearStorageText);
clearStorageButton.down = clearLocalStorage;
hud.addChild(clearStorageButton);
var bottomHud = new Container();
bottomHud.y = GAME_HEIGHT - 200; // Adjusted higher to fit larger buttons
game.addChild(bottomHud);
var upgradeButtons = {};
function createUpgradeButton(labelPrefix, x, costKey, upgradeKey, baseCost, iconType, prevTier) {
var button = LK.getAsset('button', {
size: 150,
// Increased from 80 to 150 for larger buttons
fill: 0xFFFFFF,
anchorX: 0.5,
anchorY: 0,
x: x,
y: 0
});
var costText = new Text2('$' + (baseCost * upgrades[upgradeKey]).toString(), {
size: 60,
fill: 0xFFFFFF
}); // Larger text
costText.anchor.set(0.5, 0);
costText.y = 110; // Adjusted for larger button
button.addChild(costText);
var labelText = new Text2("".concat(labelPrefix, " x").concat(upgrades[upgradeKey]), {
size: 40,
fill: 0xFFFFFF
}); // Larger text
labelText.anchor.set(0.5, 0);
labelText.y = 50; // Adjusted for larger button
button.addChild(labelText);
if (iconType) {
button.addChild(button.attachAsset(iconType, {
anchorX: 0.5,
anchorY: -0.5,
scaleX: 0.75,
scaleY: 0.75
})); // Slightly larger icons
}
button.down = function () {
var cost = baseCost * upgrades[upgradeKey];
if (!unlockedTiers[upgradeKey.split('Speed')[0].split('Power')[0]] || score < cost) {
return;
}
score -= cost;
upgrades[upgradeKey]++;
costText.setText('$' + (baseCost * upgrades[upgradeKey]).toString());
labelText.setText("".concat(labelPrefix, " x").concat(upgrades[upgradeKey]));
scoreTxt.setText('$' + score.toString());
balls.forEach(function (b) {
if (b.type === 'normal' && upgradeKey.includes('normal')) {
b[upgradeKey.includes('Speed') ? 'speed' : 'power'] = upgrades[upgradeKey];
} else if (b.type === 'splash' && upgradeKey.includes('splash')) {
b[upgradeKey.includes('Speed') ? 'speed' : 'power'] = upgrades[upgradeKey];
} else if (b.type === 'sniper' && upgradeKey.includes('sniper')) {
b[upgradeKey.includes('Speed') ? 'speed' : 'power'] = upgrades[upgradeKey];
} else if ((b.type === 'scatter' || b.type === 'smallScatter') && upgradeKey.includes('scatter')) {
b[upgradeKey.includes('Speed') ? 'speed' : 'power'] = upgrades[upgradeKey];
}
});
};
button.updateState = function () {
var isEnabled = (prevTier ? unlockedTiers[prevTier] : true) && score >= baseCost * upgrades[upgradeKey];
button.tint = isEnabled ? 0xFFFFFF : 0x666666;
button.interactive = isEnabled;
};
bottomHud.addChild(button);
upgradeButtons[upgradeKey] = button;
}
// Adjusted Upgrade Buttons with larger size and wider spacing
var buttonWidth = 150; // Size of each button
var spacing = 50; // Space between buttons
var totalButtons = 9;
var totalWidth = totalButtons * buttonWidth + (totalButtons - 1) * spacing;
var startX = (GAME_WIDTH - totalWidth) / 2; // Center the buttons
createUpgradeButton('Speed', startX, 'normalSpeedCost', 'normalSpeed', 50, 'ball', null);
createUpgradeButton('Power', startX + (buttonWidth + spacing), 'normalPowerCost', 'normalPower', 75, 'ball', null);
createUpgradeButton('Speed', startX + 2 * (buttonWidth + spacing), 'splashSpeedCost', 'splashSpeed', 50, 'splashBall', 'normal');
createUpgradeButton('Power', startX + 3 * (buttonWidth + spacing), 'splashPowerCost', 'splashPower', 75, 'splashBall', 'normal');
createUpgradeButton('Speed', startX + 4 * (buttonWidth + spacing), 'sniperSpeedCost', 'sniperSpeed', 75, 'sniperBall', 'splash');
createUpgradeButton('Power', startX + 5 * (buttonWidth + spacing), 'sniperPowerCost', 'sniperPower', 100, 'sniperBall', 'splash');
createUpgradeButton('Speed', startX + 6 * (buttonWidth + spacing), 'scatterSpeedCost', 'scatterSpeed', 50, 'scatterBall', 'sniper');
createUpgradeButton('Power', startX + 7 * (buttonWidth + spacing), 'scatterPowerCost', 'scatterPower', 75, 'scatterBall', 'sniper');
createUpgradeButton('Click', startX + 8 * (buttonWidth + spacing), 'clickCost', 'clickDamage', 25, null, null);
// Helper Functions
function updateButtonStates() {
for (var type in ballButtons) {
ballButtons[type].updateState();
}
for (var key in upgradeButtons) {
upgradeButtons[key].updateState();
}
}
function handleBallBrickCollision(ball, brick) {
var relativeX = (ball.x - brick.x) / (brick.width / 2);
var relativeY = (ball.y - brick.y) / (brick.height / 2);
if (Math.abs(relativeX) > Math.abs(relativeY)) {
ball.direction.x = -ball.direction.x + relativeX * 0.5;
ball.x = brick.x + (relativeX > 0 ? brick.width / 2 + BALL_RADIUS : -brick.width / 2 - BALL_RADIUS);
} else {
ball.direction.y = -ball.direction.y;
ball.y = brick.y + (relativeY > 0 ? brick.height / 2 + BALL_RADIUS : -brick.height / 2 - BALL_RADIUS);
}
ball.direction.x += (Math.random() - 0.5) * 0.1;
var magnitude = Math.sqrt(ball.direction.x * ball.direction.x + ball.direction.y * ball.direction.y);
ball.direction.x /= magnitude;
ball.direction.y /= magnitude;
}
function applySplashDamage(brick, gridSize) {
var gridX = Math.floor(brick.x / gridSize);
var gridY = Math.floor(brick.y / gridSize);
var adjacentKeys = ["".concat(gridX - 1, ",").concat(gridY), "".concat(gridX + 1, ",").concat(gridY), "".concat(gridX, ",").concat(gridY - 1), "".concat(gridX, ",").concat(gridY + 1)];
adjacentKeys.forEach(function (key) {
if (brickGrid[key]) {
brickGrid[key].forEach(function (adjBrick) {
if (adjBrick && adjBrick.health > 0) {
adjBrick.hit(Math.floor(upgrades.splashPower * 0.25));
}
});
}
});
}
function scatterOnImpact(ball) {
for (var i = 0; i < 4; i++) {
var smallBall = new Ball('smallScatter');
smallBall.x = ball.x;
smallBall.y = ball.y;
var angle = i / 4 * 2 * Math.PI;
smallBall.direction.x = Math.cos(angle);
smallBall.direction.y = Math.sin(angle);
balls.push(smallBall);
game.addChild(smallBall);
}
}
function findNearestBrick(x, y) {
if (bricks.length === 0) {
return null;
}
return bricks.reduce(function (closest, brick) {
var dx = brick.x - x;
var dy = brick.y - y;
var distance = Math.sqrt(dx * dx + dy * dy);
return !closest || distance < closest.distance ? {
brick: brick,
distance: distance
} : closest;
}, null).brick;
}
function isNearBricks(x, y) {
if (!brickGridBounds) {
return true;
}
var buffer = BALL_RADIUS * 2;
return x >= brickGridBounds.minX - buffer && x <= brickGridBounds.maxX + buffer && y >= brickGridBounds.minY - buffer && y <= brickGridBounds.maxY + buffer;
}
function createBricks() {
var config = levelConfig[level] || {};
var totalBricks = config.totalBricks || 50;
var hitpoints = config.hitpoints || 1;
var gridSize = config.gridSize || 200;
var pattern = config.pattern || 'grid';
var spacingX = 2;
var spacingY = 2;
brickGrid = {};
bricks = [];
var cols = Math.floor(GAME_WIDTH / (BRICK_WIDTH + spacingX));
var rows = Math.ceil(totalBricks / cols);
var totalWidth = cols * BRICK_WIDTH + (cols - 1) * spacingX;
var totalHeight = rows * BRICK_HEIGHT + (rows - 1) * spacingY;
var startX = (GAME_WIDTH - totalWidth) / 2 + BRICK_WIDTH / 2;
var startY = (GAME_HEIGHT - totalHeight) / 3 + BRICK_HEIGHT / 2;
var brickCount = 0;
if (pattern === 'grid') {
for (var i = 0; i < rows && brickCount < totalBricks; i++) {
for (var j = 0; j < cols && brickCount < totalBricks; j++) {
addBrick(startX + j * (BRICK_WIDTH + spacingX), startY + i * (BRICK_HEIGHT + spacingY), hitpoints, gridSize);
brickCount++;
}
}
} else if (pattern === 'staggered') {
for (var i = 0; i < rows && brickCount < totalBricks; i++) {
var offsetX = i % 2 === 0 ? 0 : BRICK_WIDTH / 2;
for (var j = 0; j < cols && brickCount < totalBricks; j++) {
addBrick(startX + offsetX + j * (BRICK_WIDTH + spacingX), startY + i * (BRICK_HEIGHT + spacingY), hitpoints, gridSize);
brickCount++;
}
}
} else if (pattern === 'clustered') {
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), hitpoints, gridSize);
brickCount++;
}
}
} else if (pattern === 'diagonal') {
var stepX = (GAME_WIDTH - BRICK_WIDTH) / (totalBricks - 1);
var stepY = GAME_HEIGHT / 3 / (totalBricks - 1);
for (var i = 0; i < totalBricks; i++) {
addBrick(startX + i * stepX, startY + i * stepY, hitpoints, gridSize);
brickCount++;
}
} else if (pattern === 'sparse') {
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, hitpoints, gridSize);
brickCount++;
}
}
}
brickGridBounds = {
minX: Math.min.apply(Math, _toConsumableArray(bricks.map(function (b) {
return b.x - BRICK_WIDTH / 2;
}))),
maxX: Math.max.apply(Math, _toConsumableArray(bricks.map(function (b) {
return b.x + BRICK_WIDTH / 2;
}))),
minY: Math.min.apply(Math, _toConsumableArray(bricks.map(function (b) {
return b.y - BRICK_HEIGHT / 2;
}))),
maxY: Math.max.apply(Math, _toConsumableArray(bricks.map(function (b) {
return b.y + BRICK_HEIGHT / 2;
})))
};
}
function addBrick(x, y, hitpoints, gridSize) {
var brick = new Brick();
brick.x = x;
brick.y = y;
brick.health = hitpoints;
brick.maxHealth = hitpoints;
brick.healthText.setText(brick.health.toString());
brick.updateTint();
bricks.push(brick);
game.addChild(brick);
var gridX = Math.floor(brick.x / gridSize);
var gridY = Math.floor(brick.y / gridSize);
var gridKey = "".concat(gridX, ",").concat(gridY);
if (!brickGrid[gridKey]) {
brickGrid[gridKey] = [];
}
brickGrid[gridKey].push(brick);
}
function createBall() {
var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'normal';
var ball = new Ball(type);
var gridBottom = brickGridBounds ? brickGridBounds.maxY + 150 : GAME_HEIGHT * 0.7;
ball.x = GAME_WIDTH / 2 + (Math.random() * 200 - 100);
ball.y = Math.min(gridBottom + 100, GAME_HEIGHT - BALL_RADIUS * 2);
var angle = (Math.random() * 0.5 + 0.25) * Math.PI;
ball.direction.x = Math.cos(angle);
ball.direction.y = -Math.sin(angle);
var magnitude = Math.sqrt(ball.direction.x * ball.direction.x + ball.direction.y * ball.direction.y);
ball.direction.x /= magnitude;
ball.direction.y /= magnitude;
for (var i = 0; i < bricks.length; i++) {
if (ball.intersects(bricks[i])) {
ball.y = brickGridBounds.maxY + BALL_RADIUS + 10;
break;
}
}
balls.push(ball);
game.addChild(ball);
if (!unlockedTiers[type]) {
unlockedTiers[type] = true;
storage.unlockedTiers = unlockedTiers;
updateButtonStates();
}
}
game.update = function () {
for (var i = balls.length - 1; i >= 0; i--) {
var ball = balls[i];
ball.update();
if (ball.y > GAME_HEIGHT + BALL_RADIUS) {
ball.destroy();
balls.splice(i, 1);
}
}
if (bricks.length === 0) {
if (level === Object.keys(levelConfig).length) {
LK.showGameOver();
} else {
level += 1;
storage.level = level;
levelTxt.setText('Level: ' + level);
createBricks();
}
}
if (balls.length === 0 && score >= BALL_COST) {
score -= BALL_COST;
scoreTxt.setText('$' + score.toString());
createBall();
}
updateButtonStates();
};
game.down = function (x, y, obj) {
if (!bricks || !Array.isArray(bricks)) {
return;
}
x = Number(x);
y = Number(y);
for (var i = 0; i < bricks.length; i++) {
var brick = bricks[i];
if (!brick.x || !brick.y || !brick.width || !brick.height) {
continue;
}
if (x >= brick.x - brick.width / 2 && x <= brick.x + brick.width / 2 && y >= brick.y - brick.height / 2 && y <= brick.y + brick.height / 2) {
brick.hit(upgrades.clickDamage);
return;
}
}
};
// Initialize game elements
createBricks();
createBall();
updateButtonStates(); ===================================================================
--- original.js
+++ change.js
@@ -40,14 +40,12 @@
self.y += dy;
if (self.x <= BALL_RADIUS || self.x >= GAME_WIDTH - BALL_RADIUS) {
self.direction.x *= -1;
self.x = Math.max(BALL_RADIUS, Math.min(GAME_WIDTH - BALL_RADIUS, self.x));
- LK.getSound('bounce').play(); // Play bounce sound
}
if (self.y <= BALL_RADIUS || self.y >= GAME_HEIGHT - BALL_RADIUS) {
self.direction.y *= -1;
self.y = Math.max(BALL_RADIUS, Math.min(GAME_HEIGHT - BALL_RADIUS, self.y));
- LK.getSound('bounce').play(); // Play bounce sound
}
if (!isNearBricks(self.x, self.y)) {
return;
}
@@ -137,9 +135,9 @@
/****
* Game Code
****/
-// Constants
+// Unused in this update
var _storage$unlockedTier, _storage$unlockedTier2, _storage$unlockedTier3, _storage$unlockedTier4;
function _toConsumableArray(r) {
return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
@@ -178,9 +176,8 @@
var BRICK_WIDTH = 300;
var BRICK_HEIGHT = 99;
var BALL_COST = 50;
var LEVEL_COLORS = [0xff00ff, 0x00ffcc, 0xccff00, 0xff6600, 0x66ffff, 0xff3366, 0xffcc00, 0x9966ff, 0x33cc33, 0xff0000];
-// Game Variables
var levelConfig = {
1: {
totalBricks: 30,
hitpoints: 1,
@@ -240,13 +237,10 @@
var brickGrid = {};
var score = storage.score || 0;
var level = storage.level || 1;
var brickGridBounds = null;
-// Track unlocked ball tiers
var unlockedTiers = {
- normal: true,
- // Normal is always unlocked
- // Normal is always unlocked
+ normal: ((_storage$unlockedTier = storage.unlockedTiers) === null || _storage$unlockedTier === void 0 ? void 0 : _storage$unlockedTier.normal) || true,
splash: ((_storage$unlockedTier2 = storage.unlockedTiers) === null || _storage$unlockedTier2 === void 0 ? void 0 : _storage$unlockedTier2.splash) || false,
sniper: ((_storage$unlockedTier3 = storage.unlockedTiers) === null || _storage$unlockedTier3 === void 0 ? void 0 : _storage$unlockedTier3.sniper) || false,
scatter: ((_storage$unlockedTier4 = storage.unlockedTiers) === null || _storage$unlockedTier4 === void 0 ? void 0 : _storage$unlockedTier4.scatter) || false
};
@@ -285,12 +279,11 @@
size: 60,
fill: 0xFFFFFF
});
levelTxt.anchor.set(1, 0);
-levelTxt.x = scoreTxt.x + 100; //{1x.1}
-levelTxt.y = scoreTxt.height + 10; //{1x.1}
+levelTxt.x = scoreTxt.x + 100;
+levelTxt.y = scoreTxt.height + 10;
hud.addChild(levelTxt);
-// Ball Purchase Buttons
var ballButtons = {};
function createBallButton(type, x, cost, asset, prevTier) {
var button = LK.getAsset('button', {
size: 80,
@@ -327,9 +320,9 @@
}
};
button.updateState = function () {
var isEnabled = (prevTier ? unlockedTiers[prevTier] : true) && score >= cost;
- button.tint = isEnabled ? 0xFFFFFF : 0x666666; // White if enabled, grey if locked
+ button.tint = isEnabled ? 0xFFFFFF : 0x666666;
button.interactive = isEnabled;
};
hud.addChild(button);
ballButtons[type] = button;
@@ -355,42 +348,42 @@
clearStorageButton.addChild(clearStorageText);
clearStorageButton.down = clearLocalStorage;
hud.addChild(clearStorageButton);
var bottomHud = new Container();
-bottomHud.y = GAME_HEIGHT - 150;
+bottomHud.y = GAME_HEIGHT - 200; // Adjusted higher to fit larger buttons
game.addChild(bottomHud);
var upgradeButtons = {};
function createUpgradeButton(labelPrefix, x, costKey, upgradeKey, baseCost, iconType, prevTier) {
var button = LK.getAsset('button', {
- size: 80,
+ size: 150,
+ // Increased from 80 to 150 for larger buttons
fill: 0xFFFFFF,
anchorX: 0.5,
anchorY: 0,
x: x,
y: 0
});
- var costText = new Text2((baseCost * upgrades[upgradeKey]).toString(), {
- size: 50,
+ var costText = new Text2('$' + (baseCost * upgrades[upgradeKey]).toString(), {
+ size: 60,
fill: 0xFFFFFF
- });
+ }); // Larger text
costText.anchor.set(0.5, 0);
- costText.y = 100;
+ costText.y = 110; // Adjusted for larger button
button.addChild(costText);
var labelText = new Text2("".concat(labelPrefix, " x").concat(upgrades[upgradeKey]), {
- size: 50,
- // Match size with costText
+ size: 40,
fill: 0xFFFFFF
- });
- labelText.anchor.set(0.5, 0); // Align with costText
- labelText.y = 50; // Ensure same spacing as costText
+ }); // Larger text
+ labelText.anchor.set(0.5, 0);
+ labelText.y = 50; // Adjusted for larger button
button.addChild(labelText);
if (iconType) {
button.addChild(button.attachAsset(iconType, {
anchorX: 0.5,
anchorY: -0.5,
- scaleX: 0.5,
- scaleY: 0.5
- }));
+ scaleX: 0.75,
+ scaleY: 0.75
+ })); // Slightly larger icons
}
button.down = function () {
var cost = baseCost * upgrades[upgradeKey];
if (!unlockedTiers[upgradeKey.split('Speed')[0].split('Power')[0]] || score < cost) {
@@ -420,18 +413,23 @@
};
bottomHud.addChild(button);
upgradeButtons[upgradeKey] = button;
}
-// Extended Upgrade Buttons with tiered unlocking
-createUpgradeButton('Speed', GAME_WIDTH / 2 - 600, 'normalSpeedCost', 'normalSpeed', 50, 'ball', null);
-createUpgradeButton('Power', GAME_WIDTH / 2 - 480, 'normalPowerCost', 'normalPower', 75, 'ball', null);
-createUpgradeButton('Speed', GAME_WIDTH / 2 - 360, 'splashSpeedCost', 'splashSpeed', 50, 'splashBall', 'normal');
-createUpgradeButton('Power', GAME_WIDTH / 2 - 240, 'splashPowerCost', 'splashPower', 75, 'splashBall', 'normal');
-createUpgradeButton('Speed', GAME_WIDTH / 2 - 120, 'sniperSpeedCost', 'sniperSpeed', 75, 'sniperBall', 'splash');
-createUpgradeButton('Power', GAME_WIDTH / 2, 'sniperPowerCost', 'sniperPower', 100, 'sniperBall', 'splash');
-createUpgradeButton('Speed', GAME_WIDTH / 2 + 120, 'scatterSpeedCost', 'scatterSpeed', 50, 'scatterBall', 'sniper');
-createUpgradeButton('Power', GAME_WIDTH / 2 + 240, 'scatterPowerCost', 'scatterPower', 75, 'scatterBall', 'sniper');
-createUpgradeButton('Click', GAME_WIDTH / 2 + 360, 'clickCost', 'clickDamage', 25, null, null);
+// Adjusted Upgrade Buttons with larger size and wider spacing
+var buttonWidth = 150; // Size of each button
+var spacing = 50; // Space between buttons
+var totalButtons = 9;
+var totalWidth = totalButtons * buttonWidth + (totalButtons - 1) * spacing;
+var startX = (GAME_WIDTH - totalWidth) / 2; // Center the buttons
+createUpgradeButton('Speed', startX, 'normalSpeedCost', 'normalSpeed', 50, 'ball', null);
+createUpgradeButton('Power', startX + (buttonWidth + spacing), 'normalPowerCost', 'normalPower', 75, 'ball', null);
+createUpgradeButton('Speed', startX + 2 * (buttonWidth + spacing), 'splashSpeedCost', 'splashSpeed', 50, 'splashBall', 'normal');
+createUpgradeButton('Power', startX + 3 * (buttonWidth + spacing), 'splashPowerCost', 'splashPower', 75, 'splashBall', 'normal');
+createUpgradeButton('Speed', startX + 4 * (buttonWidth + spacing), 'sniperSpeedCost', 'sniperSpeed', 75, 'sniperBall', 'splash');
+createUpgradeButton('Power', startX + 5 * (buttonWidth + spacing), 'sniperPowerCost', 'sniperPower', 100, 'sniperBall', 'splash');
+createUpgradeButton('Speed', startX + 6 * (buttonWidth + spacing), 'scatterSpeedCost', 'scatterSpeed', 50, 'scatterBall', 'sniper');
+createUpgradeButton('Power', startX + 7 * (buttonWidth + spacing), 'scatterPowerCost', 'scatterPower', 75, 'scatterBall', 'sniper');
+createUpgradeButton('Click', startX + 8 * (buttonWidth + spacing), 'clickCost', 'clickDamage', 25, null, null);
// Helper Functions
function updateButtonStates() {
for (var type in ballButtons) {
ballButtons[type].updateState();
@@ -616,9 +614,8 @@
}
}
balls.push(ball);
game.addChild(ball);
- // Unlock the next tier when a ball is bought
if (!unlockedTiers[type]) {
unlockedTiers[type] = true;
storage.unlockedTiers = unlockedTiers;
updateButtonStates();
@@ -647,9 +644,9 @@
score -= BALL_COST;
scoreTxt.setText('$' + score.toString());
createBall();
}
- updateButtonStates(); // Update button states each frame
+ updateButtonStates();
};
game.down = function (x, y, obj) {
if (!bricks || !Array.isArray(bricks)) {
return;
@@ -669,5 +666,5 @@
};
// Initialize game elements
createBricks();
createBall();
-updateButtonStates(); // Initial button state update
\ No newline at end of file
+updateButtonStates();
\ No newline at end of file
Images
:quality(85)/https://cdn.frvr.ai/67dab235ed4e4720c972d123.png%3F3)
:quality(85)/https://cdn.frvr.ai/67dab25aed4e4720c972d125.png%3F3)
:quality(85)/https://cdn.frvr.ai/67dab2804c81bb9f3792104c.png%3F3)
:quality(85)/https://cdn.frvr.ai/67dab2b5ed4e4720c972d127.png%3F3)
:quality(85)/https://cdn.frvr.ai/67dab2e94c81bb9f3792104e.png%3F3)
:quality(85)/https://cdn.frvr.ai/67dab367ed4e4720c972d129.png%3F3)
Sounds & Music
Used plugins
@upit/tween@upit/storage
