Play
:quality(85)/https://cdn.frvr.ai/683c2702f6b5261fe2bc1d6a.png)
:quality(85)/https://cdn.frvr.ai/683c2616f6b5261fe2bc1d5f.png)
#MobileGame
Creation History
User prompt
Instead of writing "you won" it should say "you completed the dungeon" with dungeon style
User prompt
snake boss should not release red things
User prompt
make a cooldown for mage
User prompt
mage is so hard fix tjat
User prompt
Let our character scream when he dies
User prompt
Every time we kill a boss, a win sound will be heard.
User prompt
Reduce the number of stone throws by the first boss
User prompt
make the first room sound is a dungeon but 2. room is a rock sound
User prompt
put the dungeon sound I chose in the background
User prompt
bosslar chestin ve npcnin içinde doğmasın
User prompt
bosslar kapıda spawnlanmasın
User prompt
Thedemon boss can stun us, throw something at us and freeze us for 1 second and it says stunned above us ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
3. boss çok güçlü düzelt
User prompt
Delete the pink things in the top left
User prompt
başlangıç ekranı buglu lütfen düzelt
User prompt
I can't click anywhere,ü
User prompt
At the beginning of the game, it asks us which language we want to play in and it can be Turkish or English. ↪💡 Consider importing and using the following plugins: @upit/storage.v1
User prompt
Let there be a labyrinth in the room where the snake is
User prompt
There should be an ultimate button next to the heal button, but it should come every 10 seconds.
User prompt
let the background be dark and let there be light behind our player
User prompt
After the mage sends us a ball, let it have a cooldown
User prompt
The devil in the 2nd room will shoot fire from the ground and if we stay in the right place the boss will die
User prompt
After the monster in the first room sends us its stones, it does not send them for 2 seconds.
User prompt
The monster in the first room sends us stones ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
The color of the life bar should be white but the inside should be red
/****
* Plugins
****/
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");
/****
* Classes
****/
// Chest class
var Chest = Container.expand(function () {
var self = Container.call(this);
// Attach chest asset (brown box)
var chestSprite = self.attachAsset('chest', {
anchorX: 0.5,
anchorY: 0.5
});
self.width = chestSprite.width;
self.height = chestSprite.height;
self.opened = false;
return self;
});
// Dark Mage - Room 3
var DarkMage = Container.expand(function () {
var self = Container.call(this);
// Use mage asset instead of monster asset
var mageSprite = self.attachAsset('mage', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 1.1,
scaleY: 1.1
});
// Set larger hitbox for easier collision detection
self.width = mageSprite.width * 0.4;
self.height = mageSprite.height * 0.4;
// Monster health system
self.maxHealth = 3;
self.health = self.maxHealth;
self.speed = 0.6;
// Create heart-based health display
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0x654321;
heart.x = startX + h * heartSpacing;
heart.y = -mageSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
// Update heart display
self.updateHealthBar = function () {
// Update heart visibility based on current health
for (var h = 0; h < self.hearts.length; h++) {
if (h < self.health) {
self.hearts[h].visible = true;
self.hearts[h].tint = 0x654321; // Brown for full hearts
self.hearts[h].alpha = 1.0;
} else {
self.hearts[h].visible = true;
self.hearts[h].tint = 0x444444; // Dark gray for empty hearts
self.hearts[h].alpha = 0.5;
}
}
};
// Take damage function with animation
self.takeDamage = function () {
self.health -= 1;
self.updateHealthBar();
// Flash damage animation
tween(mageSprite, {
tint: 0xFF0000
}, {
duration: 150,
onFinish: function onFinish() {
tween(mageSprite, {
tint: 0xFFFFFF
}, {
duration: 200
});
}
});
// Shake animation
var originalX = self.x;
tween(self, {
x: originalX + 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX - 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX
}, {
duration: 50
});
}
});
}
});
};
// Movement direction
self.vx = 0;
self.vy = 0;
// Set random direction
self.setRandomDirection = function () {
var angle = Math.random() * Math.PI * 2;
self.vx = Math.cos(angle) * self.speed;
self.vy = Math.sin(angle) * self.speed;
};
self.setRandomDirection();
// Shooting timer
self.shootTimer = 0;
self.shootInterval = 90; // Shoot every 1.5 seconds at 60fps
self.shootCooldown = 0; // Cooldown timer after shooting
self.cooldownDuration = 120; // 2 seconds at 60fps
// Called every tick
self.update = function () {
// Check if hero is close to this monster FIRST (within encounter distance)
var dx = hero.x - self.x;
var dy = hero.y - self.y;
var distToHero = Math.sqrt(dx * dx + dy * dy);
// If hero is within encounter distance, trigger freeze and stop moving
if (distToHero < 120) {
// Reduced from 200 to 120 for less aggressive encounter
if (!gameFrozen) {
// Trigger freeze effect
gameFrozen = true;
freezeTimer = FREEZE_DURATION;
freezeBuffer = FREEZE_BUFFER_TIME; // Set buffer to prevent immediate damage
console.log("Freeze triggered! Buffer set to:", FREEZE_BUFFER_TIME);
// Apply freeze visual effect to all characters
tween(hero, {
tint: 0x8888ff
}, {
duration: 300
});
tween(self, {
tint: 0x8888ff
}, {
duration: 300
});
for (var m = 0; m < monsters.length; m++) {
if (monsters[m] !== self) {
tween(monsters[m], {
tint: 0x8888ff
}, {
duration: 300
});
}
}
}
// Monster stays still when encountering hero
return;
}
// Don't move if game is frozen
if (gameFrozen) {
return;
}
// Update cooldown timer
if (self.shootCooldown > 0) {
self.shootCooldown--;
}
// Mage shooting logic - shoot projectiles at hero (only if cooldown is 0)
if (self.shootCooldown <= 0) {
self.shootTimer++;
if (self.shootTimer >= self.shootInterval) {
self.shootTimer = 0;
self.shootCooldown = self.cooldownDuration; // Start 2-second cooldown
// Create magic ball projectile
var ball = new MageBall();
ball.x = self.x;
ball.y = self.y;
ball.setDirection(hero.x, hero.y);
game.addChild(ball);
mageBalls.push(ball);
// Visual effect when shooting
tween(mageSprite, {
scaleX: 1.3,
scaleY: 1.3
}, {
duration: 200,
onFinish: function onFinish() {
tween(mageSprite, {
scaleX: 1.1,
scaleY: 1.1
}, {
duration: 200
});
}
});
}
}
self.x += self.vx;
self.y += self.vy;
// Bounce off room walls
if (self.x < roomBounds.x + self.width / 2) {
self.x = roomBounds.x + self.width / 2;
self.vx *= -1;
}
if (self.x > roomBounds.x + roomBounds.width - self.width / 2) {
self.x = roomBounds.x + roomBounds.width - self.width / 2;
self.vx *= -1;
}
if (self.y < roomBounds.y + self.height / 2) {
self.y = roomBounds.y + self.height / 2;
self.vy *= -1;
}
if (self.y > roomBounds.y + roomBounds.height - self.height / 2) {
self.y = roomBounds.y + roomBounds.height - self.height / 2;
self.vy *= -1;
}
};
// Update hearts for new health
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0x654321;
heart.x = startX + h * heartSpacing;
heart.y = -mageSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
self.updateHealthBar();
return self;
});
// Door class (for next room)
var Door = Container.expand(function () {
var self = Container.call(this);
// Attach door asset (purple box)
var doorSprite = self.attachAsset('door', {
anchorX: 0.5,
anchorY: 0.5
});
self.width = doorSprite.width;
self.height = doorSprite.height;
return self;
});
// Dragon Lord - Final Boss Room 5
var DragonLord = Container.expand(function () {
var self = Container.call(this);
// Use dragon asset instead of monster asset
var dragonSprite = self.attachAsset('dragon', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2.0,
scaleY: 2.0
});
// Set larger hitbox for easier collision detection
self.width = dragonSprite.width * 0.4;
self.height = dragonSprite.height * 0.4;
// Monster health system
self.maxHealth = 6;
self.health = self.maxHealth;
self.speed = 0.2;
// Create heart-based health display
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0xFF1744;
heart.x = startX + h * heartSpacing;
heart.y = -dragonSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
// Update heart display
self.updateHealthBar = function () {
// Update heart visibility based on current health
for (var h = 0; h < self.hearts.length; h++) {
if (h < self.health) {
self.hearts[h].visible = true;
self.hearts[h].tint = 0xFF1744; // Red for full hearts
self.hearts[h].alpha = 1.0;
} else {
self.hearts[h].visible = true;
self.hearts[h].tint = 0x444444; // Dark gray for empty hearts
self.hearts[h].alpha = 0.5;
}
}
};
// Take damage function with animation
self.takeDamage = function () {
self.health -= 1;
self.updateHealthBar();
// Flash damage animation
tween(dragonSprite, {
tint: 0xFF0000
}, {
duration: 150,
onFinish: function onFinish() {
tween(dragonSprite, {
tint: 0xFFFFFF
}, {
duration: 200
});
}
});
// Shake animation
var originalX = self.x;
tween(self, {
x: originalX + 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX - 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX
}, {
duration: 50
});
}
});
}
});
};
// Movement direction
self.vx = 0;
self.vy = 0;
// Set random direction
self.setRandomDirection = function () {
var angle = Math.random() * Math.PI * 2;
self.vx = Math.cos(angle) * self.speed;
self.vy = Math.sin(angle) * self.speed;
};
self.setRandomDirection();
// Called every tick
self.update = function () {
// Check if hero is close to this monster FIRST (within encounter distance)
var dx = hero.x - self.x;
var dy = hero.y - self.y;
var distToHero = Math.sqrt(dx * dx + dy * dy);
// If hero is within encounter distance, trigger freeze and stop moving
if (distToHero < 120) {
// Reduced from 200 to 120 for less aggressive encounter
if (!gameFrozen) {
// Trigger freeze effect
gameFrozen = true;
freezeTimer = FREEZE_DURATION;
freezeBuffer = FREEZE_BUFFER_TIME; // Set buffer to prevent immediate damage
console.log("Freeze triggered! Buffer set to:", FREEZE_BUFFER_TIME);
// Apply freeze visual effect to all characters
tween(hero, {
tint: 0x8888ff
}, {
duration: 300
});
tween(self, {
tint: 0x8888ff
}, {
duration: 300
});
for (var m = 0; m < monsters.length; m++) {
if (monsters[m] !== self) {
tween(monsters[m], {
tint: 0x8888ff
}, {
duration: 300
});
}
}
}
// Monster stays still when encountering hero
return;
}
// Don't move if game is frozen
if (gameFrozen) {
return;
}
self.x += self.vx;
self.y += self.vy;
// Bounce off room walls
if (self.x < roomBounds.x + self.width / 2) {
self.x = roomBounds.x + self.width / 2;
self.vx *= -1;
}
if (self.x > roomBounds.x + roomBounds.width - self.width / 2) {
self.x = roomBounds.x + roomBounds.width - self.width / 2;
self.vx *= -1;
}
if (self.y < roomBounds.y + self.height / 2) {
self.y = roomBounds.y + self.height / 2;
self.vy *= -1;
}
if (self.y > roomBounds.y + roomBounds.height - self.height / 2) {
self.y = roomBounds.y + roomBounds.height - self.height / 2;
self.vy *= -1;
}
};
// Update hearts for new health
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0xFF1744;
heart.x = startX + h * heartSpacing;
heart.y = -dragonSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
self.updateHealthBar();
return self;
});
// Fire Demon - Room 4
var FireDemon = Container.expand(function () {
var self = Container.call(this);
// Use demon asset instead of monster asset
var demonSprite = self.attachAsset('demon', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 1.6,
scaleY: 1.6
});
// Set larger hitbox for easier collision detection
self.width = demonSprite.width * 0.4;
self.height = demonSprite.height * 0.4;
// Monster health system
self.maxHealth = 4;
self.health = self.maxHealth;
self.speed = 0.3;
// Create heart-based health display
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0xFF1744;
heart.x = startX + h * heartSpacing;
heart.y = -demonSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
// Update heart display
self.updateHealthBar = function () {
// Update heart visibility based on current health
for (var h = 0; h < self.hearts.length; h++) {
if (h < self.health) {
self.hearts[h].visible = true;
self.hearts[h].tint = 0xFF1744; // Red for full hearts
self.hearts[h].alpha = 1.0;
} else {
self.hearts[h].visible = true;
self.hearts[h].tint = 0x444444; // Dark gray for empty hearts
self.hearts[h].alpha = 0.5;
}
}
};
// Take damage function with animation
self.takeDamage = function () {
self.health -= 1;
self.updateHealthBar();
// Flash damage animation
tween(demonSprite, {
tint: 0xFF0000
}, {
duration: 150,
onFinish: function onFinish() {
tween(demonSprite, {
tint: 0xFFFFFF
}, {
duration: 200
});
}
});
// Shake animation
var originalX = self.x;
tween(self, {
x: originalX + 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX - 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX
}, {
duration: 50
});
}
});
}
});
};
// Movement direction
self.vx = 0;
self.vy = 0;
// Set random direction
self.setRandomDirection = function () {
var angle = Math.random() * Math.PI * 2;
self.vx = Math.cos(angle) * self.speed;
self.vy = Math.sin(angle) * self.speed;
};
self.setRandomDirection();
// Fire shooting timer
self.fireTimer = 0;
self.fireInterval = 180; // Shoot fire every 3 seconds
self.safeZoneTimer = 0;
self.safeZoneDuration = 300; // 5 seconds safe zone
self.currentSafeZone = null;
// Called every tick
self.update = function () {
// Check if hero is close to this monster FIRST (within encounter distance)
var dx = hero.x - self.x;
var dy = hero.y - self.y;
var distToHero = Math.sqrt(dx * dx + dy * dy);
// If hero is within encounter distance, trigger freeze and stop moving
if (distToHero < 120) {
// Reduced from 200 to 120 for less aggressive encounter
if (!gameFrozen) {
// Trigger freeze effect
gameFrozen = true;
freezeTimer = FREEZE_DURATION;
freezeBuffer = FREEZE_BUFFER_TIME; // Set buffer to prevent immediate damage
console.log("Freeze triggered! Buffer set to:", FREEZE_BUFFER_TIME);
// Apply freeze visual effect to all characters
tween(hero, {
tint: 0x8888ff
}, {
duration: 300
});
tween(self, {
tint: 0x8888ff
}, {
duration: 300
});
for (var m = 0; m < monsters.length; m++) {
if (monsters[m] !== self) {
tween(monsters[m], {
tint: 0x8888ff
}, {
duration: 300
});
}
}
}
// Monster stays still when encountering hero
return;
}
// Don't move if game is frozen
if (gameFrozen) {
return;
}
// Fire demon ground fire shooting logic
self.fireTimer++;
if (self.fireTimer >= self.fireInterval) {
self.fireTimer = 0;
// Create random safe zone
self.currentSafeZone = {
x: roomBounds.x + 200 + Math.random() * (roomBounds.width - 400),
y: roomBounds.y + 200 + Math.random() * (roomBounds.height - 400),
radius: 150
};
self.safeZoneTimer = self.safeZoneDuration;
// Create ground fires across the room
for (var f = 0; f < 15; f++) {
var fireX = roomBounds.x + 100 + Math.random() * (roomBounds.width - 200);
var fireY = roomBounds.y + 200 + Math.random() * (roomBounds.height - 300);
// Skip if in safe zone
var dx = fireX - self.currentSafeZone.x;
var dy = fireY - self.currentSafeZone.y;
var distToSafe = Math.sqrt(dx * dx + dy * dy);
if (distToSafe < self.currentSafeZone.radius) continue;
var groundFire = new GroundFire();
groundFire.x = fireX;
groundFire.y = fireY;
game.addChild(groundFire);
groundFires.push(groundFire);
}
// Visual indicator for safe zone
var safeIndicator = LK.getAsset('trap', {
width: self.currentSafeZone.radius * 2,
height: self.currentSafeZone.radius * 2,
anchorX: 0.5,
anchorY: 0.5
});
safeIndicator.tint = 0x00FF00; // Green safe zone
safeIndicator.alpha = 0.3;
safeIndicator.x = self.currentSafeZone.x;
safeIndicator.y = self.currentSafeZone.y;
game.addChild(safeIndicator);
self.safeIndicator = safeIndicator;
}
// Update safe zone timer
if (self.safeZoneTimer > 0) {
self.safeZoneTimer--;
// Check if hero is in safe zone
if (self.currentSafeZone) {
var dx = hero.x - self.currentSafeZone.x;
var dy = hero.y - self.currentSafeZone.y;
var distToSafe = Math.sqrt(dx * dx + dy * dy);
if (distToSafe < self.currentSafeZone.radius) {
// Hero is in safe zone, damage demon
self.takeDamage();
// Flash effect to show demon taking damage
LK.effects.flashObject(self, 0xFF4444, 300);
if (self.health <= 0) {
// Remove demon
for (var m = 0; m < monsters.length; m++) {
if (monsters[m] === self) {
monsters.splice(m, 1);
break;
}
}
monstersDefeated++;
updateScoreDisplay();
self.destroy();
}
}
}
} else {
// Clean up safe zone indicator
if (self.safeIndicator) {
self.safeIndicator.destroy();
self.safeIndicator = null;
}
self.currentSafeZone = null;
}
self.x += self.vx;
self.y += self.vy;
// Bounce off room walls
if (self.x < roomBounds.x + self.width / 2) {
self.x = roomBounds.x + self.width / 2;
self.vx *= -1;
}
if (self.x > roomBounds.x + roomBounds.width - self.width / 2) {
self.x = roomBounds.x + roomBounds.width - self.width / 2;
self.vx *= -1;
}
if (self.y < roomBounds.y + self.height / 2) {
self.y = roomBounds.y + self.height / 2;
self.vy *= -1;
}
if (self.y > roomBounds.y + roomBounds.height - self.height / 2) {
self.y = roomBounds.y + roomBounds.height - self.height / 2;
self.vy *= -1;
}
};
// Update hearts for new health
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0xFF1744;
heart.x = startX + h * heartSpacing;
heart.y = -demonSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
self.updateHealthBar();
return self;
});
// Ground Fire class for Fire Demon attacks
var GroundFire = Container.expand(function () {
var self = Container.call(this);
// Create fire visual using trap asset
var fireSprite = self.attachAsset('trap', {
anchorX: 0.5,
anchorY: 0.5,
width: 80,
height: 80
});
fireSprite.tint = 0xFF4400; // Orange-red fire color
self.width = fireSprite.width;
self.height = fireSprite.height;
// Fire properties
self.lifetime = 120; // 2 seconds at 60fps
self.damageDealt = false;
// Update fire animation
self.update = function () {
self.lifetime--;
// Animate fire flickering
fireSprite.rotation += 0.3;
fireSprite.scaleX = 0.8 + Math.sin(LK.ticks * 0.2) * 0.2;
fireSprite.scaleY = 0.8 + Math.cos(LK.ticks * 0.15) * 0.3;
// Fade out near end of lifetime
if (self.lifetime < 30) {
fireSprite.alpha = self.lifetime / 30;
}
};
return self;
});
// Hero class
var Hero = Container.expand(function () {
var self = Container.call(this);
// Attach hero asset (red box)
var heroSprite = self.attachAsset('hero', {
anchorX: 0.5,
anchorY: 0.5
});
self.width = heroSprite.width;
self.height = heroSprite.height;
// Attach sword to hero
var swordSprite = self.attachAsset('sword', {
anchorX: 0.5,
anchorY: 0.5
});
swordSprite.x = -heroSprite.width * 0.3; // Position sword to the left of hero
swordSprite.y = 0; // Center vertically with hero
swordSprite.rotation = -Math.PI / 4; // Angle the sword pointing left
// Hero stats
self.maxHealth = 3;
self.health = self.maxHealth;
self.invincible = false;
self.invincibleTimer = 0;
// Create health bar above character
// Health bar border (white outline)
self.healthBarBorder = LK.getAsset('trap', {
width: 200,
height: 40,
anchorX: 0.5,
anchorY: 0.5
});
self.healthBarBorder.tint = 0xFFFFFF; // White border
self.healthBarBorder.x = 0;
self.healthBarBorder.y = -heroSprite.height / 2 - 50; // Position above character
self.addChild(self.healthBarBorder);
// Health bar background (dark)
self.healthBarBackground = LK.getAsset('trap', {
width: 180,
height: 24,
anchorX: 0.5,
anchorY: 0.5
});
self.healthBarBackground.tint = 0x222222; // Dark gray background
self.healthBarBackground.x = 0;
self.healthBarBackground.y = -heroSprite.height / 2 - 50; // Position above character
self.addChild(self.healthBarBackground);
// Health bar fill (red color)
self.healthBarFill = LK.getAsset('trap', {
width: 180,
height: 24,
anchorX: 0.0,
anchorY: 0.5
});
self.healthBarFill.tint = 0xFF0000; // Red for health bar
self.healthBarFill.x = -90; // Left-aligned within background
self.healthBarFill.y = -heroSprite.height / 2 - 50; // Position above character
self.addChild(self.healthBarFill);
// Update health bar display
self.updateHealthBar = function () {
var healthPercent = self.health / self.maxHealth;
self.healthBarFill.scaleX = healthPercent;
// Keep health bar red color
self.healthBarFill.tint = 0xFF0000; // Always red
// Add pulsing effect when health is critical
if (healthPercent <= 0.25) {
tween(self.healthBarFill, {
alpha: 0.5
}, {
duration: 500,
loop: true,
pingpong: true
});
} else {
tween.stop(self.healthBarFill, {
alpha: true
});
self.healthBarFill.alpha = 1.0;
}
};
// Initialize health bar
self.updateHealthBar();
// Flash when hit
self.flash = function () {
tween(heroSprite, {
tint: 0xffffff
}, {
duration: 100,
onFinish: function onFinish() {
tween(heroSprite, {
tint: 0xd83318
}, {
duration: 200
});
}
});
};
// Take damage
self.takeDamage = function () {
if (self.invincible) return;
self.health -= 1;
self.flash();
self.invincible = true;
self.invincibleTimer = 60; // 1 second at 60fps
LK.effects.flashObject(self, 0xff0000, 300);
self.updateHealthBar();
// Create blood flow effect
for (var b = 0; b < 8; b++) {
var bloodDrop = LK.getAsset('trap', {
width: 12 + Math.random() * 8,
height: 12 + Math.random() * 8,
anchorX: 0.5,
anchorY: 0.5
});
bloodDrop.tint = 0xAA0000; // Dark red blood color
bloodDrop.x = self.x + (Math.random() - 0.5) * 60; // Random spread around hero
bloodDrop.y = self.y + (Math.random() - 0.5) * 40;
bloodDrop.alpha = 0.8 + Math.random() * 0.2;
game.addChild(bloodDrop);
// Animate blood drop falling and fading
var fallDistance = 80 + Math.random() * 120;
var fallDuration = 800 + Math.random() * 400;
tween(bloodDrop, {
y: bloodDrop.y + fallDistance,
alpha: 0,
scaleX: 0.3,
scaleY: 0.3
}, {
duration: fallDuration,
easing: tween.easeIn,
onFinish: function onFinish() {
bloodDrop.destroy();
}
});
}
if (self.health <= 0) {
LK.effects.flashScreen(0xff0000, 800);
// Create dungeon-themed game over overlay
var dungeonGameOverOverlay = new Container();
dungeonGameOverOverlay.zIndex = 10000; // ensure on top
// Dark background
var background = LK.getAsset('trap', {
width: 2048,
height: 2732,
anchorX: 0,
anchorY: 0,
x: 0,
y: 0
});
background.tint = 0x000000;
background.alpha = 0.8;
dungeonGameOverOverlay.addChild(background);
// Main message
var gameOverText = new Text2("You couldn't pass the dungeon...", {
size: 120,
fill: 0xFF4444,
font: "Impact, Arial Black, Tahoma"
});
gameOverText.anchor.set(0.5, 0.5);
gameOverText.x = 2048 / 2;
gameOverText.y = 1200;
dungeonGameOverOverlay.addChild(gameOverText);
// Subtitle
var subtitleText = new Text2("The darkness consumed you in Room " + currentRoom, {
size: 80,
fill: 0x888888
});
subtitleText.anchor.set(0.5, 0.5);
subtitleText.x = 2048 / 2;
subtitleText.y = 1400;
dungeonGameOverOverlay.addChild(subtitleText);
// Score display
var finalScoreText = new Text2("Monsters Defeated: " + monstersDefeated, {
size: 70,
fill: 0xFFFF88
});
finalScoreText.anchor.set(0.5, 0.5);
finalScoreText.x = 2048 / 2;
finalScoreText.y = 1600;
dungeonGameOverOverlay.addChild(finalScoreText);
game.addChild(dungeonGameOverOverlay);
// Auto restart after 3 seconds
LK.setTimeout(function () {
LK.showGameOver();
}, 3000);
}
};
// Heal
self.heal = function () {
if (self.health < self.maxHealth) {
self.health += 1;
self.updateHealthBar();
LK.effects.flashObject(self, 0x83de44, 300);
}
};
// Called every tick
self.update = function () {
if (self.invincible) {
self.invincibleTimer--;
if (self.invincibleTimer <= 0) {
self.invincible = false;
}
}
};
return self;
});
/****
* Asset Initialization
****/
// Hero: red box
// Monster: green ellipse
// Trap: yellow box
// Treasure: blue ellipse
// Door: purple box
// Key class
var Key = Container.expand(function () {
var self = Container.call(this);
// Attach key asset (gold ellipse)
var keySprite = self.attachAsset('key', {
anchorX: 0.5,
anchorY: 0.5
});
self.width = keySprite.width;
self.height = keySprite.height;
return self;
});
// Mage Ball projectile class
var MageBall = Container.expand(function () {
var self = Container.call(this);
// Create ball visual using trap asset
var ballSprite = self.attachAsset('trap', {
anchorX: 0.5,
anchorY: 0.5,
width: 60,
height: 60
});
ballSprite.tint = 0x8A2BE2; // Purple magic ball
self.width = ballSprite.width;
self.height = ballSprite.height;
// Ball properties
self.vx = 0;
self.vy = 0;
self.speed = 4;
self.lifetime = 300; // 5 seconds at 60fps
// Set direction toward hero
self.setDirection = function (targetX, targetY) {
var dx = targetX - self.x;
var dy = targetY - self.y;
var dist = Math.sqrt(dx * dx + dy * dy);
if (dist > 0) {
self.vx = dx / dist * self.speed;
self.vy = dy / dist * self.speed;
}
};
// Update ball movement
self.update = function () {
self.x += self.vx;
self.y += self.vy;
self.lifetime--;
// Add magical sparkle effect
ballSprite.rotation += 0.2;
// Bounce off room walls
if (self.x < roomBounds.x + self.width / 2) {
self.x = roomBounds.x + self.width / 2;
self.vx *= -1;
}
if (self.x > roomBounds.x + roomBounds.width - self.width / 2) {
self.x = roomBounds.x + roomBounds.width - self.width / 2;
self.vx *= -1;
}
if (self.y < roomBounds.y + self.height / 2) {
self.y = roomBounds.y + self.height / 2;
self.vy *= -1;
}
if (self.y > roomBounds.y + roomBounds.height - self.height / 2) {
self.y = roomBounds.y + roomBounds.height - self.height / 2;
self.vy *= -1;
}
};
return self;
});
// Base Monster class
var Monster = Container.expand(function () {
var self = Container.call(this);
// Attach monster asset (green ellipse)
var monsterSprite = self.attachAsset('monster', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 1.2,
scaleY: 1.2
});
// Set larger hitbox for easier collision detection
self.width = monsterSprite.width * 0.4;
self.height = monsterSprite.height * 0.4;
// Monster health system
self.maxHealth = 1;
self.health = self.maxHealth;
// Create heart-based health display
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0xFF1744; // Red heart color
heart.x = startX + h * heartSpacing;
heart.y = -monsterSprite.height / 2 - 40; // Position above monster
self.addChild(heart);
self.hearts.push(heart);
}
// Update heart display
self.updateHealthBar = function () {
// Update heart visibility based on current health
for (var h = 0; h < self.hearts.length; h++) {
if (h < self.health) {
self.hearts[h].visible = true;
self.hearts[h].tint = 0xFF1744; // Red for full hearts
self.hearts[h].alpha = 1.0;
} else {
self.hearts[h].visible = true;
self.hearts[h].tint = 0x444444; // Dark gray for empty hearts
self.hearts[h].alpha = 0.5;
}
}
};
// Initialize heart display
self.updateHealthBar();
// Take damage function with animation
self.takeDamage = function () {
self.health -= 1;
self.updateHealthBar();
// Flash damage animation
tween(monsterSprite, {
tint: 0xFF0000
}, {
duration: 150,
onFinish: function onFinish() {
tween(monsterSprite, {
tint: 0xFFFFFF
}, {
duration: 200
});
}
});
// Shake animation
var originalX = self.x;
tween(self, {
x: originalX + 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX - 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX
}, {
duration: 50
});
}
});
}
});
};
// Movement direction
self.vx = 0;
self.vy = 0;
self.speed = 0.3 + Math.random() * 0.4; // Reduced speed from 1-2 to 0.3-0.7
// Set random direction
self.setRandomDirection = function () {
var angle = Math.random() * Math.PI * 2;
self.vx = Math.cos(angle) * self.speed;
self.vy = Math.sin(angle) * self.speed;
};
self.setRandomDirection();
// Called every tick
self.update = function () {
// Check if hero is close to this monster FIRST (within encounter distance)
var dx = hero.x - self.x;
var dy = hero.y - self.y;
var distToHero = Math.sqrt(dx * dx + dy * dy);
// If hero is within encounter distance, trigger freeze and stop moving
if (distToHero < 120) {
// Reduced from 200 to 120 for less aggressive encounter
if (!gameFrozen) {
// Trigger freeze effect
gameFrozen = true;
freezeTimer = FREEZE_DURATION;
freezeBuffer = FREEZE_BUFFER_TIME; // Set buffer to prevent immediate damage
console.log("Freeze triggered! Buffer set to:", FREEZE_BUFFER_TIME);
// Apply freeze visual effect to all characters
tween(hero, {
tint: 0x8888ff
}, {
duration: 300
});
tween(self, {
tint: 0x8888ff
}, {
duration: 300
});
for (var m = 0; m < monsters.length; m++) {
if (monsters[m] !== self) {
tween(monsters[m], {
tint: 0x8888ff
}, {
duration: 300
});
}
}
}
// Monster stays still when encountering hero
return;
}
// Don't move if game is frozen
if (gameFrozen) {
return;
}
self.x += self.vx;
self.y += self.vy;
// Bounce off room walls
if (self.x < roomBounds.x + self.width / 2) {
self.x = roomBounds.x + self.width / 2;
self.vx *= -1;
}
if (self.x > roomBounds.x + roomBounds.width - self.width / 2) {
self.x = roomBounds.x + roomBounds.width - self.width / 2;
self.vx *= -1;
}
if (self.y < roomBounds.y + self.height / 2) {
self.y = roomBounds.y + self.height / 2;
self.vy *= -1;
}
if (self.y > roomBounds.y + roomBounds.height - self.height / 2) {
self.y = roomBounds.y + roomBounds.height - self.height / 2;
self.vy *= -1;
}
};
return self;
});
// NPC Wizard class - appears in first room to wish good luck
var NPCWizard = Container.expand(function () {
var self = Container.call(this);
// Attach wizard sprite
var wizardSprite = self.attachAsset('wizard', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 0.8,
scaleY: 0.8
});
self.width = wizardSprite.width;
self.height = wizardSprite.height;
// Speech bubble properties
self.showingSpeech = false;
self.speechBubble = null;
self.speechText = null;
// Show speech bubble with good luck message
self.showSpeech = function () {
if (self.showingSpeech) return;
self.showingSpeech = true;
// Create speech bubble background
self.speechBubble = LK.getAsset('door', {
width: 400,
height: 180,
anchorX: 0.5,
anchorY: 1.0
});
self.speechBubble.tint = 0xFFFFFF;
self.speechBubble.alpha = 0.9;
self.speechBubble.x = 0;
self.speechBubble.y = -wizardSprite.height / 2 - 20;
self.addChild(self.speechBubble);
// Create speech text
self.speechText = new Text2("Good luck in the dungeon,\nbrave adventurer!", {
size: 45,
fill: 0xFFFFFF,
font: "Impact, Arial Black, Tahoma"
});
self.speechText.anchor.set(0.5, 0.5);
self.speechText.x = 0;
self.speechText.y = -wizardSprite.height / 2 - 110;
self.addChild(self.speechText);
// Auto-hide speech after 4 seconds
LK.setTimeout(function () {
self.hideSpeech();
}, 4000);
};
// Hide speech bubble
self.hideSpeech = function () {
if (!self.showingSpeech) return;
self.showingSpeech = false;
if (self.speechBubble) {
self.speechBubble.destroy();
self.speechBubble = null;
}
if (self.speechText) {
self.speechText.destroy();
self.speechText = null;
}
};
return self;
});
// Orc Warrior - Room 2
var OrcWarrior = Container.expand(function () {
var self = Container.call(this);
// Use orc asset instead of monster asset
var orcSprite = self.attachAsset('orc', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 1.4,
scaleY: 1.4
});
// Set larger hitbox for easier collision detection
self.width = orcSprite.width * 0.4;
self.height = orcSprite.height * 0.4;
// Monster health system
self.maxHealth = 2;
self.health = self.maxHealth;
self.speed = 0.4;
// Create heart-based health display
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0xFF1744;
heart.x = startX + h * heartSpacing;
heart.y = -orcSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
// Update heart display
self.updateHealthBar = function () {
// Update heart visibility based on current health
for (var h = 0; h < self.hearts.length; h++) {
if (h < self.health) {
self.hearts[h].visible = true;
self.hearts[h].tint = 0xFF1744; // Red for full hearts
self.hearts[h].alpha = 1.0;
} else {
self.hearts[h].visible = true;
self.hearts[h].tint = 0x444444; // Dark gray for empty hearts
self.hearts[h].alpha = 0.5;
}
}
};
// Take damage function with animation
self.takeDamage = function () {
self.health -= 1;
self.updateHealthBar();
// Flash damage animation
tween(orcSprite, {
tint: 0xFF0000
}, {
duration: 150,
onFinish: function onFinish() {
tween(orcSprite, {
tint: 0xFFFFFF
}, {
duration: 200
});
}
});
// Shake animation
var originalX = self.x;
tween(self, {
x: originalX + 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX - 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX
}, {
duration: 50
});
}
});
}
});
};
// Movement direction
self.vx = 0;
self.vy = 0;
// Set random direction
self.setRandomDirection = function () {
var angle = Math.random() * Math.PI * 2;
self.vx = Math.cos(angle) * self.speed;
self.vy = Math.sin(angle) * self.speed;
};
self.setRandomDirection();
// Called every tick
self.update = function () {
// Check if hero is close to this monster FIRST (within encounter distance)
var dx = hero.x - self.x;
var dy = hero.y - self.y;
var distToHero = Math.sqrt(dx * dx + dy * dy);
// If hero is within encounter distance, trigger freeze and stop moving
if (distToHero < 120) {
// Reduced from 200 to 120 for less aggressive encounter
if (!gameFrozen) {
// Trigger freeze effect
gameFrozen = true;
freezeTimer = FREEZE_DURATION;
freezeBuffer = FREEZE_BUFFER_TIME; // Set buffer to prevent immediate damage
console.log("Freeze triggered! Buffer set to:", FREEZE_BUFFER_TIME);
// Apply freeze visual effect to all characters
tween(hero, {
tint: 0x8888ff
}, {
duration: 300
});
tween(self, {
tint: 0x8888ff
}, {
duration: 300
});
for (var m = 0; m < monsters.length; m++) {
if (monsters[m] !== self) {
tween(monsters[m], {
tint: 0x8888ff
}, {
duration: 300
});
}
}
}
// Monster stays still when encountering hero
return;
}
// Don't move if game is frozen
if (gameFrozen) {
return;
}
self.x += self.vx;
self.y += self.vy;
// Bounce off room walls
if (self.x < roomBounds.x + self.width / 2) {
self.x = roomBounds.x + self.width / 2;
self.vx *= -1;
}
if (self.x > roomBounds.x + roomBounds.width - self.width / 2) {
self.x = roomBounds.x + roomBounds.width - self.width / 2;
self.vx *= -1;
}
if (self.y < roomBounds.y + self.height / 2) {
self.y = roomBounds.y + self.height / 2;
self.vy *= -1;
}
if (self.y > roomBounds.y + roomBounds.height - self.height / 2) {
self.y = roomBounds.y + roomBounds.height - self.height / 2;
self.vy *= -1;
}
};
// Update hearts for new health
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0xFF1744;
heart.x = startX + h * heartSpacing;
heart.y = -orcSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
self.updateHealthBar();
return self;
});
// Skeleton Boss - Room 1
var SkeletonBoss = Container.expand(function () {
var self = Container.call(this);
// Use skeleton asset instead of monster asset
var skeletonSprite = self.attachAsset('skeleton', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 1.2,
scaleY: 1.2
});
// Set larger hitbox for easier collision detection
self.width = skeletonSprite.width * 0.4;
self.height = skeletonSprite.height * 0.4;
// Monster health system
self.maxHealth = 1;
self.health = self.maxHealth;
self.speed = 0.5;
// Create heart-based health display
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0xFF1744;
heart.x = startX + h * heartSpacing;
heart.y = -skeletonSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
// Update heart display
self.updateHealthBar = function () {
// Update heart visibility based on current health
for (var h = 0; h < self.hearts.length; h++) {
if (h < self.health) {
self.hearts[h].visible = true;
self.hearts[h].tint = 0xFF1744; // Red for full hearts
self.hearts[h].alpha = 1.0;
} else {
self.hearts[h].visible = true;
self.hearts[h].tint = 0x444444; // Dark gray for empty hearts
self.hearts[h].alpha = 0.5;
}
}
};
// Take damage function with animation
self.takeDamage = function () {
self.health -= 1;
self.updateHealthBar();
// Flash damage animation
tween(skeletonSprite, {
tint: 0xFF0000
}, {
duration: 150,
onFinish: function onFinish() {
tween(skeletonSprite, {
tint: 0xFFFFFF
}, {
duration: 200
});
}
});
// Shake animation
var originalX = self.x;
tween(self, {
x: originalX + 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX - 15
}, {
duration: 50,
onFinish: function onFinish() {
tween(self, {
x: originalX
}, {
duration: 50
});
}
});
}
});
};
// Movement direction
self.vx = 0;
self.vy = 0;
// Set random direction
self.setRandomDirection = function () {
var angle = Math.random() * Math.PI * 2;
self.vx = Math.cos(angle) * self.speed;
self.vy = Math.sin(angle) * self.speed;
};
self.setRandomDirection();
// Shooting timer
self.shootTimer = 0;
self.shootInterval = 100; // Shoot every ~1.67 seconds at 60fps
self.shootCooldown = 0; // Cooldown timer after shooting
self.cooldownDuration = 120; // 2 seconds at 60fps
// Called every tick
self.update = function () {
// Check if hero is close to this monster FIRST (within encounter distance)
var dx = hero.x - self.x;
var dy = hero.y - self.y;
var distToHero = Math.sqrt(dx * dx + dy * dy);
// If hero is within encounter distance, trigger freeze and stop moving
if (distToHero < 120) {
// Reduced from 200 to 120 for less aggressive encounter
if (!gameFrozen) {
// Trigger freeze effect
gameFrozen = true;
freezeTimer = FREEZE_DURATION;
freezeBuffer = FREEZE_BUFFER_TIME; // Set buffer to prevent immediate damage
console.log("Freeze triggered! Buffer set to:", FREEZE_BUFFER_TIME);
// Apply freeze visual effect to all characters
tween(hero, {
tint: 0x8888ff
}, {
duration: 300
});
tween(self, {
tint: 0x8888ff
}, {
duration: 300
});
for (var m = 0; m < monsters.length; m++) {
if (monsters[m] !== self) {
tween(monsters[m], {
tint: 0x8888ff
}, {
duration: 300
});
}
}
}
// Monster stays still when encountering hero
return;
}
// Don't move if game is frozen
if (gameFrozen) {
return;
}
// Update cooldown timer
if (self.shootCooldown > 0) {
self.shootCooldown--;
}
// Skeleton stone shooting logic - shoot stones at hero (only if cooldown is 0)
if (self.shootCooldown <= 0) {
self.shootTimer++;
if (self.shootTimer >= self.shootInterval) {
self.shootTimer = 0;
self.shootCooldown = self.cooldownDuration; // Start 2-second cooldown
// Create stone projectile
var stone = new SkeletonStone();
stone.x = self.x;
stone.y = self.y;
stone.setDirection(hero.x, hero.y);
game.addChild(stone);
skeletonStones.push(stone);
// Visual effect when shooting
tween(skeletonSprite, {
scaleX: 1.4,
scaleY: 1.4
}, {
duration: 250,
onFinish: function onFinish() {
tween(skeletonSprite, {
scaleX: 1.2,
scaleY: 1.2
}, {
duration: 250
});
}
});
}
}
self.x += self.vx;
self.y += self.vy;
// Bounce off room walls
if (self.x < roomBounds.x + self.width / 2) {
self.x = roomBounds.x + self.width / 2;
self.vx *= -1;
}
if (self.x > roomBounds.x + roomBounds.width - self.width / 2) {
self.x = roomBounds.x + roomBounds.width - self.width / 2;
self.vx *= -1;
}
if (self.y < roomBounds.y + self.height / 2) {
self.y = roomBounds.y + self.height / 2;
self.vy *= -1;
}
if (self.y > roomBounds.y + roomBounds.height - self.height / 2) {
self.y = roomBounds.y + roomBounds.height - self.height / 2;
self.vy *= -1;
}
};
// Skeleton stats
self.maxHealth = 1;
self.health = self.maxHealth;
self.speed = 0.5;
// Update hearts for new health
self.hearts = [];
var heartSize = 30;
var heartSpacing = 35;
var totalHeartsWidth = (self.maxHealth - 1) * heartSpacing + heartSize;
var startX = -totalHeartsWidth / 2;
for (var h = 0; h < self.maxHealth; h++) {
var heart = LK.getAsset('trap', {
width: heartSize,
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
heart.tint = 0xFF1744;
heart.x = startX + h * heartSpacing;
heart.y = -skeletonSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
}
self.updateHealthBar();
return self;
});
// Stone projectile class for skeleton boss
var SkeletonStone = Container.expand(function () {
var self = Container.call(this);
// Create stone visual using trap asset
var stoneSprite = self.attachAsset('trap', {
anchorX: 0.5,
anchorY: 0.5,
width: 50,
height: 50
});
stoneSprite.tint = 0x555555; // Gray stone color
self.width = stoneSprite.width;
self.height = stoneSprite.height;
// Stone properties
self.vx = 0;
self.vy = 0;
self.speed = 3.5;
self.lifetime = 350; // Slightly longer than mage balls
// Set direction toward hero
self.setDirection = function (targetX, targetY) {
var dx = targetX - self.x;
var dy = targetY - self.y;
var dist = Math.sqrt(dx * dx + dy * dy);
if (dist > 0) {
self.vx = dx / dist * self.speed;
self.vy = dy / dist * self.speed;
}
};
// Update stone movement
self.update = function () {
self.x += self.vx;
self.y += self.vy;
self.lifetime--;
// Add stone spinning effect
stoneSprite.rotation += 0.15;
// Bounce off room walls
if (self.x < roomBounds.x + self.width / 2) {
self.x = roomBounds.x + self.width / 2;
self.vx *= -1;
}
if (self.x > roomBounds.x + roomBounds.width - self.width / 2) {
self.x = roomBounds.x + roomBounds.width - self.width / 2;
self.vx *= -1;
}
if (self.y < roomBounds.y + self.height / 2) {
self.y = roomBounds.y + self.height / 2;
self.vy *= -1;
}
if (self.y > roomBounds.y + roomBounds.height - self.height / 2) {
self.y = roomBounds.y + roomBounds.height - self.height / 2;
self.vy *= -1;
}
};
return self;
});
/****
* Initialize Game
****/
var game = new LK.Game({
backgroundColor: 0x2C1810
});
/****
* Game Code
****/
// Create dungeon floor texture with pixel-by-pixel stone pattern
var dungeonFloor = new Container();
var stoneColors = [0x4A4A4A, 0x3A3A3A, 0x5A5A5A, 0x2A2A2A, 0x6A6A6A]; // Various gray stone colors
var mossColors = [0x2D4A2D, 0x1F3A1F, 0x3D5A3D]; // Mossy accents
var dirtColors = [0x4A3A2A, 0x5A4A3A, 0x3A2A1A]; // Dirt between stones
// Create pixelated stone floor
for (var row = 0; row < 68; row++) {
// Cover full height (2732/40 = ~68 rows)
for (var col = 0; col < 52; col++) {
// Cover full width (2048/40 = ~52 cols)
var pixelSize = 40;
var x = col * pixelSize;
var y = row * pixelSize;
// Determine pixel type based on position for realistic stone pattern
var isStone = (row + col) % 3 !== 0; // Most pixels are stone
var isMoss = Math.random() < 0.05; // 5% chance for moss
var isDirt = Math.random() < 0.08; // 8% chance for dirt
var color;
if (isMoss) {
color = mossColors[Math.floor(Math.random() * mossColors.length)];
} else if (isDirt) {
color = dirtColors[Math.floor(Math.random() * dirtColors.length)];
} else {
color = stoneColors[Math.floor(Math.random() * stoneColors.length)];
}
var pixel = LK.getAsset('trap', {
width: pixelSize,
height: pixelSize,
anchorX: 0,
anchorY: 0,
x: x,
y: y
});
pixel.tint = color;
dungeonFloor.addChild(pixel);
}
// Update lighting to follow hero
if (lightingOverlay && hero) {
// Update light position to follow hero
var playerLight = lightingOverlay.children[1]; // Second child is the main light
var innerLight = lightingOverlay.children[2]; // Third child is the inner light
if (playerLight) {
playerLight.x = hero.x;
playerLight.y = hero.y;
}
if (innerLight) {
innerLight.x = hero.x;
innerLight.y = hero.y;
}
}
}
;
// Add dungeon floor as background layer
game.addChildAt(dungeonFloor, 0); // Add at bottom layer
// Create lighting system - dark overlay with light behind player
var lightingOverlay = new Container();
lightingOverlay.zIndex = 1000; // Above most game elements but below UI
// Create dark background overlay
var darkOverlay = LK.getAsset('trap', {
width: 2048,
height: 2732,
anchorX: 0,
anchorY: 0,
x: 0,
y: 0
});
darkOverlay.tint = 0x000000; // Black overlay
darkOverlay.alpha = 0.7; // Semi-transparent to create darkness
lightingOverlay.addChild(darkOverlay);
// Create light circle behind player
var playerLight = LK.getAsset('trap', {
width: 600,
height: 600,
anchorX: 0.5,
anchorY: 0.5
});
playerLight.tint = 0xFFFFFF; // White light
playerLight.alpha = 0.8; // Light intensity
// Create soft light gradient effect
var innerLight = LK.getAsset('trap', {
width: 300,
height: 300,
anchorX: 0.5,
anchorY: 0.5
});
innerLight.tint = 0xFFFFFF;
innerLight.alpha = 0.9;
lightingOverlay.addChild(playerLight);
lightingOverlay.addChild(innerLight);
// Add lighting overlay to game
game.addChild(lightingOverlay);
// Tween plugin for animations
// Language system
var selectedLanguage = storage.language || null; // Get saved language or null if first time
var languageTexts = {
english: {
welcome: "Welcome, Hero!",
title: "Brave Adventurer",
story: "Enter the dark dungeon and face legendary monsters.\nDefeat bosses, collect treasures, and prove your courage!",
subtitle: "Tap to move and attack. Collect keys from chests to proceed!",
startButton: "START ADVENTURE",
instructions: "Tap the button above to begin your quest",
attack: "ATTACK",
heal: "HEAL",
ultimate: "ULTIMATE",
openChest: "OPEN CHEST",
score: "Score: ",
room: "Room ",
health: "Health: Full",
noHeals: "NO HEALS",
gameOver: "You couldn't pass the dungeon...",
gameOverSubtitle: "The darkness consumed you in Room ",
monstersDefeated: "Monsters Defeated: ",
selectLanguage: "Select Language",
languageInstructions: "Choose your preferred language"
},
turkish: {
welcome: "Hoş Geldin, Kahraman!",
title: "Cesur Maceracı",
story: "Karanlık zindana gir ve efsanevi canavarlarla yüzleş.\nBosları yen, hazineler topla ve cesaretini kanıtla!",
subtitle: "Hareket etmek ve saldırmak için dokun. İlerlemek için sandıklardan anahtarları topla!",
startButton: "MACERAYA BAŞLA",
instructions: "Maceranıza başlamak için yukarıdaki düğmeye dokunun",
attack: "SALDIRI",
heal: "İYİLEŞ",
ultimate: "ÜST GÜÇLER",
openChest: "SANDIĞI AÇ",
score: "Skor: ",
room: "Oda ",
health: "Sağlık: Tam",
noHeals: "İYİLEŞME YOK",
gameOver: "Zindandan geçemedin...",
gameOverSubtitle: "Karanlık seni Oda ",
monstersDefeated: "Yenilen Canavarlar: ",
selectLanguage: "Dil Seçin",
languageInstructions: "Tercih ettiğiniz dili seçin"
}
};
var currentTexts = selectedLanguage ? languageTexts[selectedLanguage] : languageTexts.english;
// Language Selection Screen (only shown if no language is saved)
var languageSelectionOverlay = null;
if (!selectedLanguage) {
languageSelectionOverlay = new Container();
languageSelectionOverlay.zIndex = 15000; // Above start screen
// Dark background
var langBackground = LK.getAsset('trap', {
width: 2048,
height: 2732,
anchorX: 0,
anchorY: 0,
x: 0,
y: 0
});
langBackground.tint = 0x000000;
langBackground.alpha = 0.9;
languageSelectionOverlay.addChild(langBackground);
// Title
var langTitle = new Text2("Select Language / Dil Seçin", {
size: 140,
fill: 0xFFD700,
font: "Impact, Arial Black, Tahoma"
});
langTitle.anchor.set(0.5, 0.5);
langTitle.x = 2048 / 2;
langTitle.y = 600;
languageSelectionOverlay.addChild(langTitle);
// Instructions
var langInstructions = new Text2("Choose your preferred language\nTercih ettiğiniz dili seçin", {
size: 80,
fill: 0xCCCCCC,
font: "Impact, Arial Black, Tahoma"
});
langInstructions.anchor.set(0.5, 0.5);
langInstructions.x = 2048 / 2;
langInstructions.y = 900;
languageSelectionOverlay.addChild(langInstructions);
// English Button
var englishButton = LK.getAsset('door', {
width: 600,
height: 200,
anchorX: 0.5,
anchorY: 0.5,
x: 2048 / 2 - 350,
y: 1400
});
englishButton.tint = 0x4A8B3B;
languageSelectionOverlay.addChild(englishButton);
var englishButtonText = new Text2("ENGLISH", {
size: 100,
fill: "#fff",
font: "Impact, Arial Black, Tahoma"
});
englishButtonText.anchor.set(0.5, 0.5);
englishButtonText.x = 2048 / 2 - 350;
englishButtonText.y = 1400;
languageSelectionOverlay.addChild(englishButtonText);
// Turkish Button
var turkishButton = LK.getAsset('door', {
width: 600,
height: 200,
anchorX: 0.5,
anchorY: 0.5,
x: 2048 / 2 + 350,
y: 1400
});
turkishButton.tint = 0x8B3A3A;
languageSelectionOverlay.addChild(turkishButton);
var turkishButtonText = new Text2("TÜRKÇE", {
size: 100,
fill: "#fff",
font: "Impact, Arial Black, Tahoma"
});
turkishButtonText.anchor.set(0.5, 0.5);
turkishButtonText.x = 2048 / 2 + 350;
turkishButtonText.y = 1400;
languageSelectionOverlay.addChild(turkishButtonText);
// Add animations
tween(englishButton, {
scaleX: 1.05,
scaleY: 1.05
}, {
duration: 1000,
loop: true,
pingpong: true
});
tween(turkishButton, {
scaleX: 1.05,
scaleY: 1.05
}, {
duration: 1000,
loop: true,
pingpong: true,
delay: 500
});
game.addChild(languageSelectionOverlay);
}
// --- Start Screen Overlay ---
var startScreenOverlay = new Container();
startScreenOverlay.zIndex = 10000; // ensure on top
// Dark background for better text readability
var startBackground = LK.getAsset('trap', {
width: 2048,
height: 2732,
anchorX: 0,
anchorY: 0,
x: 0,
y: 0
});
startBackground.tint = 0x000000;
startBackground.alpha = 0.85;
startScreenOverlay.addChild(startBackground);
// Welcome message
var welcomeText = new Text2(currentTexts.welcome, {
size: 120,
fill: 0xFFD700,
font: "Impact, Arial Black, Tahoma"
});
welcomeText.anchor.set(0.5, 0.5);
welcomeText.x = 2048 / 2;
welcomeText.y = 600;
startScreenOverlay.addChild(welcomeText);
// Title
var titleText = new Text2(currentTexts.title, {
size: 180,
fill: "#fff",
font: "Impact, Arial Black, Tahoma"
});
titleText.anchor.set(0.5, 0.5);
titleText.x = 2048 / 2;
titleText.y = 800;
startScreenOverlay.addChild(titleText);
// Story introduction
var storyText = new Text2(currentTexts.story, {
size: 60,
fill: 0xCCCCCC,
font: "Impact, Arial Black, Tahoma"
});
storyText.anchor.set(0.5, 0.5);
storyText.x = 2048 / 2;
storyText.y = 1000;
startScreenOverlay.addChild(storyText);
// Subtitle
var subtitleText = new Text2(currentTexts.subtitle, {
size: 70,
fill: 0xB8B031
});
subtitleText.anchor.set(0.5, 0.5);
subtitleText.x = 2048 / 2;
subtitleText.y = 1200;
startScreenOverlay.addChild(subtitleText);
// Play Button
var playBtnWidth = 600;
var playBtnHeight = 180;
var playBtn = LK.getAsset('door', {
width: playBtnWidth,
height: playBtnHeight,
anchorX: 0.5,
anchorY: 0.5,
x: 2048 / 2,
y: 1600
});
playBtn.tint = 0x4A8B3B; // Green tint for play button
startScreenOverlay.addChild(playBtn);
var playBtnText = new Text2(currentTexts.startButton, {
size: 90,
fill: "#fff",
font: "Impact, Arial Black, Tahoma"
});
playBtnText.anchor.set(0.5, 0.5);
playBtnText.x = 2048 / 2;
playBtnText.y = 1600;
startScreenOverlay.addChild(playBtnText);
// Add pulsing animation to play button
tween(playBtn, {
scaleX: 1.1,
scaleY: 1.1
}, {
duration: 800,
loop: true,
pingpong: true
});
tween(playBtnText, {
scaleX: 1.1,
scaleY: 1.1
}, {
duration: 800,
loop: true,
pingpong: true
});
// Instructions text
var instructionsText = new Text2(currentTexts.instructions, {
size: 50,
fill: 0x888888,
font: "Impact, Arial Black, Tahoma"
});
instructionsText.anchor.set(0.5, 0.5);
instructionsText.x = 2048 / 2;
instructionsText.y = 1800;
startScreenOverlay.addChild(instructionsText);
// Add overlay to game
game.addChild(startScreenOverlay);
// Block game input until started
var gameStarted = false;
var languageSelected = selectedLanguage ? true : false;
// Language selection handler
function selectLanguage(lang) {
if (languageSelected) return;
selectedLanguage = lang;
storage.language = lang; // Save language preference
languageSelected = true;
currentTexts = languageTexts[lang];
// Update all text elements with new language
welcomeText.setText(currentTexts.welcome);
titleText.setText(currentTexts.title);
storyText.setText(currentTexts.story);
subtitleText.setText(currentTexts.subtitle);
playBtnText.setText(currentTexts.startButton);
instructionsText.setText(currentTexts.instructions);
// Update UI elements
killButtonText.setText(currentTexts.attack);
healButtonText.setText(currentTexts.heal);
ultimateButtonText.setText(currentTexts.ultimate);
openChestText.setText(currentTexts.openChest);
scoreTxt.setText(currentTexts.score + "0");
roomTxt.setText(currentTexts.room + "1");
healthTxt.setText(currentTexts.health);
// Fade out language selection screen
if (languageSelectionOverlay && languageSelectionOverlay.visible !== false) {
tween(languageSelectionOverlay, {
alpha: 0
}, {
duration: 500,
onFinish: function onFinish() {
languageSelectionOverlay.visible = false;
}
});
}
// Flash screen to indicate language selection
LK.effects.flashScreen(0x4A8B3B, 300);
}
// Start game handler
function startGame() {
if (gameStarted || !languageSelected) return;
gameStarted = true;
// Fade out start screen with smooth transition
tween(startScreenOverlay, {
alpha: 0
}, {
duration: 500,
onFinish: function onFinish() {
startScreenOverlay.visible = false;
startScreenOverlay.alpha = 1; // Reset for potential restart
}
});
// Flash screen to indicate game start
LK.effects.flashScreen(0x4A8B3B, 300);
}
// Listen for tap/click on language buttons
if (languageSelectionOverlay) {
languageSelectionOverlay.down = function (x, y, obj) {
// Check English button
var englishLocal = englishButton.toLocal(languageSelectionOverlay.toGlobal({
x: x,
y: y
}));
if (englishLocal.x > -300 && englishLocal.x < 300 && englishLocal.y > -100 && englishLocal.y < 100) {
selectLanguage('english');
return;
}
// Check Turkish button
var turkishLocal = turkishButton.toLocal(languageSelectionOverlay.toGlobal({
x: x,
y: y
}));
if (turkishLocal.x > -300 && turkishLocal.x < 300 && turkishLocal.y > -100 && turkishLocal.y < 100) {
selectLanguage('turkish');
return;
}
};
}
// Listen for tap/click on play button
startScreenOverlay.down = function (x, y, obj) {
// Check if tap is inside play button
var local = playBtn.toLocal(startScreenOverlay.toGlobal({
x: x,
y: y
}));
if (local.x > -playBtnWidth / 2 && local.x < playBtnWidth / 2 && local.y > -playBtnHeight / 2 && local.y < playBtnHeight / 2) {
startGame();
}
};
// Store original game handlers before any interception
var originalGameDown = null;
var originalGameMove = null;
var originalGameUp = null;
// Intercept all input until game started
game.down = function (x, y, obj) {
if (!languageSelected && languageSelectionOverlay && languageSelectionOverlay.visible) {
if (typeof languageSelectionOverlay.down === "function") languageSelectionOverlay.down(x, y, obj);
return;
}
if (!gameStarted && startScreenOverlay && startScreenOverlay.visible) {
if (typeof startScreenOverlay.down === "function") startScreenOverlay.down(x, y, obj);
return;
}
// Call the actual game down handler defined later
if (typeof originalGameDown === "function") originalGameDown(x, y, obj);
};
game.move = function (x, y, obj) {
if (!languageSelected && languageSelectionOverlay && languageSelectionOverlay.visible || !gameStarted && startScreenOverlay && startScreenOverlay.visible) return;
// Call the actual game move handler defined later
if (typeof originalGameMove === "function") originalGameMove(x, y, obj);
};
game.up = function (x, y, obj) {
if (!languageSelected && languageSelectionOverlay && languageSelectionOverlay.visible || !gameStarted && startScreenOverlay && startScreenOverlay.visible) return;
// Call the actual game up handler defined later
if (typeof originalGameUp === "function") originalGameUp(x, y, obj);
};
// Room bounds (centered, with margin)
var roomMargin = 120;
var roomBounds = {
x: roomMargin,
y: roomMargin + 100,
// leave top 100px for menu
width: 2048 - roomMargin * 2,
height: 2732 - roomMargin * 2 - 100
};
// Game state
var hero;
var monsters = [];
var mageBalls = []; // Track mage projectiles
var skeletonStones = []; // Track skeleton stone projectiles
var groundFires = []; // Track ground fire projectiles
var door;
var keys = [];
var chests = [];
var hasKey = false;
var draggingHero = false;
var lastMoveX = 0,
lastMoveY = 0;
var currentRoom = 1;
var maxRooms = 5;
var monstersDefeated = 0;
var roomCleared = false;
var gameFrozen = false;
var freezeTimer = 0;
var FREEZE_DURATION = 120; // 2 seconds at 60fps
var freezeBuffer = 0; // Buffer to prevent immediate damage after freeze
var FREEZE_BUFFER_TIME = 30; // 30 frames buffer after freeze starts (0.5 seconds)
var healUsesRemaining = 3; // Player can use heal 3 times total
var ultimateTimer = 0; // Timer for ultimate button availability
var ultimateInterval = 600; // 10 seconds at 60fps
var ultimateAvailable = false; // Whether ultimate button should be shown
// GUI elements
var scoreTxt = new Text2('Score: 0', {
size: 90,
fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
scoreTxt.y = 20;
LK.gui.top.addChild(scoreTxt);
// Room indicator
var roomTxt = new Text2('Room 1', {
size: 80,
fill: 0xFFD700
});
roomTxt.anchor.set(0, 0);
roomTxt.x = 120;
roomTxt.y = 20;
LK.gui.topLeft.addChild(roomTxt);
// Health indicator text
var healthTxt = new Text2('Health: Full', {
size: 70,
fill: 0xFF4444
});
healthTxt.anchor.set(1, 0);
healthTxt.x = -20;
healthTxt.y = 20;
LK.gui.topRight.addChild(healthTxt);
// Helper to update health display - now updates the health bar on the character
function updateHealthDisplay() {
// This will be handled by the health bar on the character
}
// Helper to update score display
function updateScoreDisplay() {
var score = monstersDefeated * 5;
scoreTxt.setText(currentTexts.score + score);
}
// Helper to update room display
function updateRoomDisplay() {
roomTxt.setText(currentTexts.room + currentRoom);
}
// Helper to update health display
// Helper to clear room
function clearRoom() {
for (var i = 0; i < monsters.length; i++) monsters[i].destroy();
for (var i = 0; i < keys.length; i++) keys[i].destroy();
for (var i = 0; i < chests.length; i++) chests[i].destroy();
for (var i = 0; i < mageBalls.length; i++) mageBalls[i].destroy();
for (var i = 0; i < skeletonStones.length; i++) skeletonStones[i].destroy();
for (var i = 0; i < groundFires.length; i++) groundFires[i].destroy();
monsters = [];
keys = [];
chests = [];
mageBalls = [];
skeletonStones = [];
groundFires = [];
if (door) {
door.destroy();
door = null;
}
// Clear NPC reference if it exists
if (game.npcWizard) {
game.npcWizard.destroy();
game.npcWizard = null;
}
roomCleared = false;
hasKey = false;
}
// Helper to generate a room
function generateRoom(roomNum) {
clearRoom();
// Place hero at entrance (bottom center)
hero.x = roomBounds.x + roomBounds.width / 2;
hero.y = roomBounds.y + roomBounds.height - hero.height;
// Helper function to check if position is safe from hero spawn area
function isPositionSafeFromHeroSpawn(x, y, heroStartX, heroStartY, safeDistance) {
var dx = x - heroStartX;
var dy = y - heroStartY;
var dist = Math.sqrt(dx * dx + dy * dy);
return dist > safeDistance;
}
// Place monsters - exactly 1 boss monster per room based on room number
var monsterCount = 1;
var heroStartX = roomBounds.x + roomBounds.width / 2;
var heroStartY = roomBounds.y + roomBounds.height - hero.height;
var heroSafeDistance = 400; // Increased safe distance around hero spawn
for (var i = 0; i < monsterCount; i++) {
var m;
// Create different boss types based on room number
if (roomNum === 1) {
m = new SkeletonBoss();
} else if (roomNum === 2) {
m = new OrcWarrior();
} else if (roomNum === 3) {
m = new DarkMage();
} else if (roomNum === 4) {
m = new FireDemon();
} else if (roomNum === 5) {
m = new DragonLord();
} else {
// Fallback for any additional rooms
m = new Monster();
}
var validPosition = false;
var attempts = 0;
// Try to find a position that's not too close to hero spawn
while (!validPosition && attempts < 50) {
m.x = roomBounds.x + 100 + Math.random() * (roomBounds.width - 200);
m.y = roomBounds.y + 200 + Math.random() * (roomBounds.height - 400);
if (isPositionSafeFromHeroSpawn(m.x, m.y, heroStartX, heroStartY, heroSafeDistance)) {
validPosition = true;
}
attempts++;
}
monsters.push(m);
game.addChild(m);
}
// Key will come from chest after killing all monsters, so don't place it randomly
// Place chest (always one per room)
var c = new Chest();
var validPosition = false;
var attempts = 0;
while (!validPosition && attempts < 50) {
c.x = roomBounds.x + 100 + Math.random() * (roomBounds.width - 200);
c.y = roomBounds.y + 200 + Math.random() * (roomBounds.height - 400);
if (isPositionSafeFromHeroSpawn(c.x, c.y, heroStartX, heroStartY, heroSafeDistance)) {
validPosition = true;
}
attempts++;
}
chests.push(c);
game.addChild(c);
// Place door (top center)
door = new Door();
door.x = roomBounds.x + roomBounds.width / 2;
door.y = roomBounds.y + door.height / 2;
game.addChild(door);
door.visible = false; // Only show when room is cleared
// Place NPC wizard only in first room
if (roomNum === 1) {
var npcWizard = new NPCWizard();
npcWizard.x = roomBounds.x + 200; // Position near left wall
npcWizard.y = roomBounds.y + roomBounds.height / 2; // Center vertically
game.addChild(npcWizard);
// Store reference for proximity check
game.npcWizard = npcWizard;
}
roomCleared = false;
updateRoomDisplay();
updateHealthDisplay();
}
// Create hero
hero = new Hero();
game.addChild(hero);
// Start first room
generateRoom(currentRoom);
updateScoreDisplay();
// Store this as the original game up handler
originalGameUp = function originalGameUp(x, y, obj) {
draggingHero = false;
};
function clamp(val, min, max) {
return Math.max(min, Math.min(max, val));
}
// Walk-to destination variables
var walkToActive = false;
var walkToX = 0;
var walkToY = 0;
var walkToSpeed = 22;
// Attack button for attacking monsters - round dungeon-themed button
var killButton = LK.getAsset('monster', {
width: 280,
height: 280,
anchorX: 0.5,
anchorY: 0.5,
x: 2048 - 160,
y: 2732 - 160
});
killButton.tint = 0x4A4A4A; // Dark steel gray for shield-like appearance
killButton.alpha = 0.9; // Slightly transparent for better integration
game.addChild(killButton);
var killButtonText = new Text2("ATTACK", {
size: 60,
fill: 0xFFD700,
font: "Impact, Arial Black, Tahoma"
});
killButtonText.anchor.set(0.5, 0.5);
killButtonText.x = 2048 - 160;
killButtonText.y = 2732 - 160;
game.addChild(killButtonText);
// Heal pot button next to attack button
var healButton = LK.getAsset('chest', {
width: 280,
height: 280,
anchorX: 0.5,
anchorY: 0.5,
x: 2048 - 460,
// Position to the left of attack button
y: 2732 - 160
});
healButton.tint = 0xFF4444; // Red tint for health potion
healButton.alpha = 0.9;
game.addChild(healButton);
var healButtonText = new Text2("HEAL", {
size: 60,
fill: 0xFFD700,
font: "Impact, Arial Black, Tahoma"
});
healButtonText.anchor.set(0.5, 0.5);
healButtonText.x = 2048 - 460;
healButtonText.y = 2732 - 160;
game.addChild(healButtonText);
// Ultimate button next to heal button
var ultimateButton = LK.getAsset('sword', {
width: 280,
height: 280,
anchorX: 0.5,
anchorY: 0.5,
x: 2048 - 760,
// Position to the left of heal button
y: 2732 - 160
});
ultimateButton.tint = 0xFF8800; // Orange tint for ultimate ability
ultimateButton.alpha = 0.9;
ultimateButton.visible = false; // Initially hidden
game.addChild(ultimateButton);
var ultimateButtonText = new Text2("ULTIMATE", {
size: 50,
fill: 0xFFD700,
font: "Impact, Arial Black, Tahoma"
});
ultimateButtonText.anchor.set(0.5, 0.5);
ultimateButtonText.x = 2048 - 760;
ultimateButtonText.y = 2732 - 160;
ultimateButtonText.visible = false; // Initially hidden
game.addChild(ultimateButtonText);
// Open chest text
var openChestText = new Text2("OPEN CHEST", {
size: 80,
fill: 0xFFD700,
font: "Impact, Arial Black, Tahoma"
});
openChestText.anchor.set(0.5, 0.5);
openChestText.x = 2048 / 2;
openChestText.y = 2732 - 200;
openChestText.visible = false;
game.addChild(openChestText);
// Sword swing state management
var swordSwinging = false;
var swordCooldown = 0;
var SWORD_COOLDOWN_TIME = 15; // frames (0.25 seconds at 60fps)
// Store this as the original game move handler
originalGameMove = function originalGameMove(x, y, obj) {
if (draggingHero) {
// Clamp hero inside room bounds
var hx = clamp(x, roomBounds.x + hero.width / 2, roomBounds.x + roomBounds.width - hero.width / 2);
var hy = clamp(y, roomBounds.y + hero.height / 2, roomBounds.y + roomBounds.height - hero.height / 2);
hero.x = hx;
hero.y = hy;
walkToActive = false; // Cancel walk-to if dragging
}
};
// Initialize originalGameDown properly before it's used
if (!originalGameDown) {
originalGameDown = function originalGameDown(x, y, obj) {
// Only start drag if touch is on hero
var local = hero.toLocal(game.toGlobal({
x: x,
y: y
}));
// Check if heal button was tapped
var healButtonLocal = healButton.toLocal(game.toGlobal({
x: x,
y: y
}));
if (healButtonLocal.x > -healButton.width / 2 && healButtonLocal.x < healButton.width / 2 && healButtonLocal.y > -healButton.height / 2 && healButtonLocal.y < healButton.height / 2) {
// Check if we have heal uses remaining
if (healUsesRemaining > 0) {
// Use heal function from hero
hero.heal();
healUsesRemaining--;
}
return; // Don't process other touch logic
}
// Check if ultimate button was tapped
var ultimateButtonLocal = ultimateButton.toLocal(game.toGlobal({
x: x,
y: y
}));
if (ultimateAvailable && ultimateButtonLocal.x > -ultimateButton.width / 2 && ultimateButtonLocal.x < ultimateButton.width / 2 && ultimateButtonLocal.y > -ultimateButton.height / 2 && ultimateButtonLocal.y < ultimateButton.height / 2) {
// Use ultimate ability - damage all monsters on screen and heal hero
for (var i = monsters.length - 1; i >= 0; i--) {
var m = monsters[i];
m.takeDamage();
// Check if monster is dead
if (m.health <= 0) {
// Remove monster
m.destroy();
monsters.splice(i, 1);
monstersDefeated++;
updateScoreDisplay();
}
}
// Heal hero to full health
hero.health = hero.maxHealth;
hero.updateHealthBar();
// Visual effects
LK.effects.flashScreen(0xFFD700, 500);
LK.effects.flashObject(hero, 0xFFD700, 500);
// Reset ultimate timer
ultimateTimer = 0;
ultimateAvailable = false;
ultimateButton.visible = false;
ultimateButtonText.visible = false;
return; // Don't process other touch logic
}
// Check if kill button was tapped
var killButtonLocal = killButton.toLocal(game.toGlobal({
x: x,
y: y
}));
if (killButtonLocal.x > -killButton.width / 2 && killButtonLocal.x < killButton.width / 2 && killButtonLocal.y > -killButton.height / 2 && killButtonLocal.y < killButton.height / 2) {
// Check if sword is available (not swinging and cooldown expired)
if (!swordSwinging && swordCooldown <= 0) {
// Get sword sprite from hero for animation
var swordSprite = hero.children[1]; // Sword is the second child (index 1)
// Stop any existing tweens on the sword
tween.stop(swordSprite, {
rotation: true
});
// Set swinging state
swordSwinging = true;
swordCooldown = SWORD_COOLDOWN_TIME;
// Create sword swing effect
var originalRotation = swordSprite.rotation;
tween(swordSprite, {
rotation: originalRotation + Math.PI / 2
}, {
duration: 150,
easing: tween.easeOut,
onFinish: function onFinish() {
tween(swordSprite, {
rotation: originalRotation
}, {
duration: 200,
easing: tween.easeIn,
onFinish: function onFinish() {
swordSwinging = false;
}
});
}
});
// Kill button tapped - damage all monsters within 350px of hero
for (var i = monsters.length - 1; i >= 0; i--) {
var m = monsters[i];
var dx = hero.x - m.x;
var dy = hero.y - m.y;
var dist = Math.sqrt(dx * dx + dy * dy);
if (dist < 500) {
// Deal damage to monster
m.takeDamage();
// Optional: flash hero for feedback
LK.effects.flashObject(hero, 0xffffff, 120);
// Check if monster is dead
if (m.health <= 0) {
// Remove monster
m.destroy();
monsters.splice(i, 1);
monstersDefeated++;
updateScoreDisplay();
}
// Unfreeze game when monster dies
if (gameFrozen) {
gameFrozen = false;
freezeTimer = 0;
// Remove freeze visual effects
tween(hero, {
tint: 0xffffff
}, {
duration: 300
});
for (var j = 0; j < monsters.length; j++) {
tween(monsters[j], {
tint: 0xffffff
}, {
duration: 300
});
}
}
}
}
}
return; // Don't process other touch logic
}
if (local.x > -hero.width / 2 && local.x < hero.width / 2 && local.y > -hero.height / 2 && local.y < hero.height / 2) {
draggingHero = true;
lastMoveX = x;
lastMoveY = y;
walkToActive = false;
} else {
// Set walk-to destination if tap is inside room
var hx = clamp(x, roomBounds.x + hero.width / 2, roomBounds.x + roomBounds.width - hero.width / 2);
var hy = clamp(y, roomBounds.y + hero.height / 2, roomBounds.y + roomBounds.height - hero.height / 2);
walkToX = hx;
walkToY = hy;
walkToActive = true;
}
// Original handler logic is now properly stored and called
};
}
// In update, move hero toward walk-to destination if active
var oldGameUpdate = game.update;
game.update = function () {
// Walk-to logic
if (walkToActive && !draggingHero) {
var dx = walkToX - hero.x;
var dy = walkToY - hero.y;
var dist = Math.sqrt(dx * dx + dy * dy);
if (dist > walkToSpeed) {
hero.x += dx / dist * walkToSpeed;
hero.y += dy / dist * walkToSpeed;
} else {
hero.x = walkToX;
hero.y = walkToY;
walkToActive = false;
}
}
if (typeof oldGameUpdate === "function") oldGameUpdate();
};
// Main update loop
game.update = function () {
if (!gameStarted) return;
// Handle freeze timer
if (gameFrozen) {
freezeTimer--;
if (freezeTimer <= 0) {
// Unfreeze game
gameFrozen = false;
// Remove freeze visual effects
tween(hero, {
tint: 0xffffff
}, {
duration: 300
});
for (var m = 0; m < monsters.length; m++) {
tween(monsters[m], {
tint: 0xffffff
}, {
duration: 300
});
}
}
}
// Update sword cooldown
if (swordCooldown > 0) {
swordCooldown--;
}
// Update ultimate timer
if (!ultimateAvailable) {
ultimateTimer++;
if (ultimateTimer >= ultimateInterval) {
ultimateAvailable = true;
ultimateButton.visible = true;
ultimateButtonText.visible = true;
// Add pulsing animation to indicate availability
tween(ultimateButton, {
scaleX: 1.2,
scaleY: 1.2
}, {
duration: 600,
loop: true,
pingpong: true
});
tween(ultimateButtonText, {
scaleX: 1.2,
scaleY: 1.2
}, {
duration: 600,
loop: true,
pingpong: true
});
}
}
// Update freeze buffer
if (freezeBuffer > 0) {
freezeBuffer--;
}
// Update hero (only if not frozen)
if (!gameFrozen) {
hero.update();
}
// Update monsters
for (var i = 0; i < monsters.length; i++) {
monsters[i].update();
}
// Update mage balls
for (var i = mageBalls.length - 1; i >= 0; i--) {
var ball = mageBalls[i];
ball.update();
// Remove ball if lifetime expired
if (ball.lifetime <= 0) {
ball.destroy();
mageBalls.splice(i, 1);
continue;
}
// Check collision with hero (only when not invincible and no freeze buffer)
if (!hero.invincible && freezeBuffer <= 0 && hero.intersects(ball)) {
hero.takeDamage();
// Destroy ball on hit
ball.destroy();
mageBalls.splice(i, 1);
// Create impact effect
LK.effects.flashObject(hero, 0x8A2BE2, 200);
}
}
// Update skeleton stones
for (var i = skeletonStones.length - 1; i >= 0; i--) {
var stone = skeletonStones[i];
stone.update();
// Remove stone if lifetime expired
if (stone.lifetime <= 0) {
stone.destroy();
skeletonStones.splice(i, 1);
continue;
}
// Check collision with hero (only when not invincible and no freeze buffer)
if (!hero.invincible && freezeBuffer <= 0 && hero.intersects(stone)) {
hero.takeDamage();
// Destroy stone on hit
stone.destroy();
skeletonStones.splice(i, 1);
// Create impact effect
LK.effects.flashObject(hero, 0x555555, 200);
}
}
// Update ground fires
for (var i = groundFires.length - 1; i >= 0; i--) {
var fire = groundFires[i];
fire.update();
// Remove fire if lifetime expired
if (fire.lifetime <= 0) {
fire.destroy();
groundFires.splice(i, 1);
continue;
}
// Check collision with hero (only when not invincible and no freeze buffer)
if (!hero.invincible && freezeBuffer <= 0 && !fire.damageDealt && hero.intersects(fire)) {
hero.takeDamage();
fire.damageDealt = true; // Prevent multiple damage from same fire
// Create fire impact effect
LK.effects.flashObject(hero, 0xFF4400, 200);
}
}
// Attack button is always visible
killButton.visible = true;
killButtonText.visible = true;
// Heal button visibility and text update based on remaining uses
if (healUsesRemaining > 0) {
healButton.visible = true;
healButtonText.visible = true;
healButton.alpha = 0.9;
healButtonText.setText(currentTexts.heal + " (" + healUsesRemaining + ")");
} else {
healButton.visible = true;
healButtonText.visible = true;
healButton.alpha = 0.3; // Make button appear disabled
healButtonText.setText(currentTexts.noHeals);
}
// Check if hero is close to chest and all monsters are defeated
var nearChest = false;
if (monsters.length === 0) {
for (var i = 0; i < chests.length; i++) {
var c = chests[i];
if (!c.opened) {
var dx = hero.x - c.x;
var dy = hero.y - c.y;
var dist = Math.sqrt(dx * dx + dy * dy);
if (dist < 200) {
nearChest = true;
break;
}
}
}
}
// Show/hide open chest text based on proximity and game state
openChestText.visible = nearChest;
// Check collisions: hero vs monsters (only when game is not frozen, no freeze buffer, and hero is not invincible)
if (!gameFrozen && freezeBuffer <= 0 && !hero.invincible) {
for (var i = monsters.length - 1; i >= 0; i--) {
var m = monsters[i];
if (hero.intersects(m)) {
hero.takeDamage();
// No knockback - hero stays in place when touching monsters
// Hero can only kill monsters with the kill button, not by collision
}
}
}
// Check collisions: hero vs keys
for (var i = keys.length - 1; i >= 0; i--) {
var k = keys[i];
if (hero.intersects(k)) {
k.destroy();
keys.splice(i, 1);
hasKey = true;
LK.effects.flashObject(hero, 0xFFD700, 300);
}
}
// Check collisions: hero vs chests
for (var i = 0; i < chests.length; i++) {
var c = chests[i];
if (hero.intersects(c) && monsters.length === 0 && !c.opened) {
c.opened = true;
LK.effects.flashObject(c, 0x83de44, 600);
updateScoreDisplay();
// Spawn key from chest after all monsters are defeated
var k = new Key();
k.x = c.x;
k.y = c.y;
keys.push(k);
game.addChild(k);
}
}
// Room clear check - need to defeat all monsters first, then open chest, then collect key
if (!roomCleared && monsters.length === 0 && chests.length > 0 && chests[0].opened && hasKey) {
roomCleared = true;
door.visible = true;
LK.effects.flashObject(door, 0x83de44, 600);
}
// Check if hero is near NPC wizard in first room
if (currentRoom === 1 && game.npcWizard && !game.npcWizard.showingSpeech) {
var dx = hero.x - game.npcWizard.x;
var dy = hero.y - game.npcWizard.y;
var distToNPC = Math.sqrt(dx * dx + dy * dy);
if (distToNPC < 250) {
// Show speech when hero gets close
game.npcWizard.showSpeech();
}
}
// Check hero at door to next room
if (roomCleared && door && hero.intersects(door)) {
if (currentRoom < maxRooms) {
currentRoom++;
generateRoom(currentRoom);
} else {
// Win!
LK.setScore(monstersDefeated * 5);
LK.showYouWin();
}
}
}; ===================================================================
--- original.js
+++ change.js
@@ -49,9 +49,9 @@
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
- heart.tint = 0xFF1744;
+ heart.tint = 0x654321;
heart.x = startX + h * heartSpacing;
heart.y = -mageSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
@@ -61,9 +61,9 @@
// Update heart visibility based on current health
for (var h = 0; h < self.hearts.length; h++) {
if (h < self.health) {
self.hearts[h].visible = true;
- self.hearts[h].tint = 0xFF1744; // Red for full hearts
+ self.hearts[h].tint = 0x654321; // Brown for full hearts
self.hearts[h].alpha = 1.0;
} else {
self.hearts[h].visible = true;
self.hearts[h].tint = 0x444444; // Dark gray for empty hearts
@@ -234,9 +234,9 @@
height: heartSize,
anchorX: 0.5,
anchorY: 0.5
});
- heart.tint = 0xFF1744;
+ heart.tint = 0x654321;
heart.x = startX + h * heartSpacing;
heart.y = -mageSprite.height / 2 - 40;
self.addChild(heart);
self.hearts.push(heart);
Images
:quality(85)/https://cdn.frvr.ai/683c0711f6b5261fe2bc1c11.png%3F3)
dungeon door. No background. Transparent background. Blank background. No shadows. 2d. In-Game asset. flat
:quality(85)/https://cdn.frvr.ai/683c099ef6b5261fe2bc1c57.png%3F3)
png
:quality(85)/https://cdn.frvr.ai/683c09ddf6b5261fe2bc1c61.png%3F3)
dungeon hero sword. No background. Transparent background. Blank background. No shadows. 2d. In-Game asset. flat
:quality(85)/https://cdn.frvr.ai/683c0c45f6b5261fe2bc1c71.png%3F3)
dungeon key. No background. Transparent background. Blank background. No shadows. 2d. In-Game asset. flat
:quality(85)/https://cdn.frvr.ai/683c0d93f6b5261fe2bc1c7d.png%3F3)
dungeon chest. No background. Transparent background. Blank background. No shadows. 2d. In-Game asset. flat
:quality(85)/https://cdn.frvr.ai/683c15cef6b5261fe2bc1cb3.png%3F3)
dungeon demon. No background. Transparent background. Blank background. No shadows. 2d. In-Game asset. flat
:quality(85)/https://cdn.frvr.ai/683c161bf6b5261fe2bc1cb8.png%3F3)
dungeon wizard. No background. Transparent background. Blank background. No shadows. 2d. In-Game asset. flat
:quality(85)/https://cdn.frvr.ai/683c1768f6b5261fe2bc1cc1.png%3F3)
a mage who throws fireballs. No background. Transparent background. Blank background. No shadows. 2d. In-Game asset. flat
:quality(85)/https://cdn.frvr.ai/683c1a5ff6b5261fe2bc1ce1.png%3F3)
big dungeon snake. No background. Transparent background. Blank background. No shadows. 2d. In-Game asset. flat
:quality(85)/https://cdn.frvr.ai/683c22d3f6b5261fe2bc1d31.png%3F3)
a spider. No background. Transparent background. Blank background. No shadows. 2d. In-Game asset. flat
Sounds & Music
Used plugins
@upit/tween@upit/storage
