Play
:quality(85)/https://cdn.frvr.ai/68718cc00a62997a6828fccb.png)
:quality(85)/https://cdn.frvr.ai/6871841782a0bb11be9745b1.png)
#3D
#maze
#raycasting
#puzzle
#firstperson
#doors
Creation History
User prompt
Rename game name and description and tags
User prompt
Make the door look more obvious and have a nameplate to show the dimensions of the door. Also add small details like small paintings, desks, and more
User prompt
I cant tell were is forward and were is back sometimes I dont know where the door is and progression is confusing.
User prompt
Make sure to reset all values and memory on new game. Make doors actually look like doors and add numbers on the doors. Make player move slower
User prompt
Make the hallway actually a hallway, use raycasting to add shelfs, beds, and paintings
User prompt
Make it so that theres only one way forward and unique room shapes: Hallway, L shaped, Library, bedroom
User prompt
Please fix the bug: 'undefined is not an object (evaluating 'maze.grid[doorY][doorX + h] = 0')' in or related to this line: 'maze.grid[doorY][doorX + h] = 0;' Line Number: 89
User prompt
Make rooms proceedurally generated up to the 100th room, Make rooms smaller and dont do flashing lights
User prompt
Cannot move. Also remove minimap on top, then make it so that doors are seperately colors and automatically open on touch, and after each room add a counter, at 100 rooms the player wins
User prompt
Make individual rooms with doors between them, use the roblox game “doors” as a reference
User prompt
I meant the lower corners
User prompt
Make arrow larger and move arrows to the corners then remove the backward arrow and add rooms and doors
User prompt
Expand screen size to full as it is cut in half. Then make it so that the forward arrow is at the left and left and right are at the right side
User prompt
When doing more than 2 actions the entire application crashes
User prompt
game completely crashes when moving foward
User prompt
Add forward back, and left and right camera arrows
Code edit (1 edits merged)
Please save this source code
User prompt
Maze Runner 3D
Initial prompt
Make a 3d raycasting maze game
/****
* Plugins
****/
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");
/****
* Classes
****/
var MazeGenerator = Container.expand(function () {
var self = Container.call(this);
self.generate = function (width, height) {
var maze = {
width: width,
height: height,
grid: [],
startX: 1,
startY: 1,
endX: width - 2,
endY: height - 2,
rooms: [],
currentRoom: 0
};
// Initialize maze with walls
for (var y = 0; y < height; y++) {
maze.grid[y] = [];
for (var x = 0; x < width; x++) {
maze.grid[y][x] = 1; // Wall
}
}
// Create linear sequence of rooms like Doors game
self.createLinearRooms(maze);
// Ensure start and end are open
maze.grid[maze.startY][maze.startX] = 0;
maze.grid[maze.endY][maze.endX] = 2; // Exit
return maze;
};
self.createLinearRooms = function (maze) {
// Create a linear sequence of rooms connected by doors (like Doors game)
var roomCount = 3 + Math.floor(Math.random() * 2); // 3-4 rooms
var roomWidth = 5;
var roomHeight = 5;
var hallwayWidth = 3;
// Calculate total width needed
var totalWidth = roomCount * roomWidth + (roomCount - 1) * hallwayWidth;
var startX = Math.floor((maze.width - totalWidth) / 2);
var startY = Math.floor((maze.height - roomHeight) / 2);
maze.rooms = [];
// Create rooms and connecting hallways
for (var r = 0; r < roomCount; r++) {
var roomX = startX + r * (roomWidth + hallwayWidth);
var roomY = startY;
// Store room info
maze.rooms.push({
x: roomX,
y: roomY,
width: roomWidth,
height: roomHeight,
number: r + 1
});
// Clear room area
for (var y = roomY; y < roomY + roomHeight; y++) {
for (var x = roomX; x < roomX + roomWidth; x++) {
if (x < maze.width && y < maze.height) {
maze.grid[y][x] = 0;
}
}
}
// Add door to next room (except for last room)
if (r < roomCount - 1) {
var doorX = roomX + roomWidth;
var doorY = roomY + Math.floor(roomHeight / 2);
// Create hallway to next room
for (var h = 0; h < hallwayWidth; h++) {
if (doorX + h < maze.width) {
maze.grid[doorY][doorX + h] = 0;
}
}
// Place door at end of hallway
if (doorX + hallwayWidth - 1 < maze.width) {
maze.grid[doorY][doorX + hallwayWidth - 1] = 3; // Door
}
}
}
// Set start in first room
maze.startX = maze.rooms[0].x + 1;
maze.startY = maze.rooms[0].y + 1;
// Set exit in last room
var lastRoom = maze.rooms[maze.rooms.length - 1];
maze.endX = lastRoom.x + lastRoom.width - 2;
maze.endY = lastRoom.y + lastRoom.height - 2;
};
return self;
});
var Minimap = Container.expand(function () {
var self = Container.call(this);
self.cellSize = 8;
self.mapCells = [];
self.playerDot = null;
self.setup = function (maze) {
// Clear existing map
for (var i = 0; i < self.mapCells.length; i++) {
self.mapCells[i].destroy();
}
self.mapCells = [];
if (self.playerDot) {
self.playerDot.destroy();
}
// Create minimap cells
for (var y = 0; y < maze.height; y++) {
for (var x = 0; x < maze.width; x++) {
var cell = null;
if (maze.grid[y][x] === 1) {
// Wall
cell = LK.getAsset('wall', {
width: self.cellSize,
height: self.cellSize,
anchorX: 0,
anchorY: 0
});
cell.tint = 0x444444;
} else if (maze.grid[y][x] === 2) {
// Exit
cell = LK.getAsset('exit', {
width: self.cellSize,
height: self.cellSize,
anchorX: 0,
anchorY: 0
});
cell.tint = 0x00FF00;
} else if (maze.grid[y][x] === 3) {
// Door
cell = LK.getAsset('door', {
width: self.cellSize,
height: self.cellSize,
anchorX: 0,
anchorY: 0
});
cell.tint = 0x654321;
} else {
// Open path
cell = LK.getAsset('floor', {
width: self.cellSize,
height: self.cellSize,
anchorX: 0,
anchorY: 0
});
cell.tint = 0x888888;
}
if (cell) {
cell.x = x * self.cellSize;
cell.y = y * self.cellSize;
self.addChild(cell);
self.mapCells.push(cell);
}
}
}
// Create player dot
self.playerDot = LK.getAsset('player', {
width: self.cellSize,
height: self.cellSize,
anchorX: 0.5,
anchorY: 0.5
});
self.addChild(self.playerDot);
};
self.updatePlayer = function (playerX, playerY) {
if (self.playerDot) {
self.playerDot.x = playerX * self.cellSize;
self.playerDot.y = playerY * self.cellSize;
}
};
return self;
});
var RaycastRenderer = Container.expand(function () {
var self = Container.call(this);
self.fov = Math.PI / 3; // 60 degrees field of view
self.rayCount = 256; // Number of rays to cast (expanded for full screen)
self.maxDistance = 15; // Reduced max distance
self.wallHeight = 300;
self.walls = [];
self.render = function (playerX, playerY, playerAngle, maze) {
// Initialize walls array if needed
if (self.walls.length === 0) {
for (var i = 0; i < self.rayCount; i++) {
var wall = LK.getAsset('raycast_wall', {
width: 8,
height: self.wallHeight,
anchorX: 0,
anchorY: 0.5
});
wall.x = i * 8;
wall.y = 2732 / 2;
wall.visible = false;
self.addChild(wall);
self.walls.push(wall);
}
}
var angleStep = self.fov / self.rayCount;
var rayAngle = playerAngle - self.fov / 2;
for (var i = 0; i < self.rayCount; i++) {
var distance = self.castRay(playerX, playerY, rayAngle, maze);
var wall = self.walls[i];
if (distance < self.maxDistance) {
// Calculate wall height based on distance
var wallHeight = self.wallHeight / distance;
if (wallHeight > 600) wallHeight = 600; // Cap wall height
// Update existing wall segment
wall.height = wallHeight;
wall.visible = true;
// Add depth shading
var shade = Math.max(0.2, 1 - distance / self.maxDistance);
wall.tint = self.interpolateColor(0x000000, 0x8B4513, shade);
} else {
wall.visible = false;
}
rayAngle += angleStep;
}
};
self.castRay = function (x, y, angle, maze) {
var dx = Math.cos(angle) * 0.1;
var dy = Math.sin(angle) * 0.1;
var distance = 0;
var stepSize = 0.1;
var maxSteps = 200; // Prevent infinite loops
var steps = 0;
while (distance < self.maxDistance && steps < maxSteps) {
x += dx;
y += dy;
distance += stepSize;
steps++;
var mapX = Math.floor(x);
var mapY = Math.floor(y);
if (mapX < 0 || mapX >= maze.width || mapY < 0 || mapY >= maze.height) {
return distance;
}
if (maze.grid[mapY][mapX] === 1 || maze.grid[mapY][mapX] === 3) {
return distance;
}
}
return self.maxDistance;
};
self.interpolateColor = function (color1, color2, factor) {
var r1 = color1 >> 16 & 0xFF;
var g1 = color1 >> 8 & 0xFF;
var b1 = color1 & 0xFF;
var r2 = color2 >> 16 & 0xFF;
var g2 = color2 >> 8 & 0xFF;
var b2 = color2 & 0xFF;
var r = Math.floor(r1 + (r2 - r1) * factor);
var g = Math.floor(g1 + (g2 - g1) * factor);
var b = Math.floor(b1 + (b2 - b1) * factor);
return r << 16 | g << 8 | b;
};
return self;
});
/****
* Initialize Game
****/
var game = new LK.Game({
backgroundColor: 0x000000
});
/****
* Game Code
****/
// Game variables
var currentLevel = storage.currentLevel || 1;
var playerX = 1.5;
var playerY = 1.5;
var playerAngle = 0;
var moveSpeed = 0.05;
var turnSpeed = 0.05;
var maze = null;
var mazeGenerator = new MazeGenerator();
var raycastRenderer = new RaycastRenderer();
var minimap = new Minimap();
// Touch controls
var touchStartX = 0;
var touchStartY = 0;
var isTouching = false;
var moveForward = false;
var moveBackward = false;
var turnLeft = false;
var turnRight = false;
// UI elements
var levelText = new Text2('Level: ' + currentLevel, {
size: 60,
fill: 0xFFFFFF
});
levelText.anchor.set(0.5, 0);
LK.gui.top.addChild(levelText);
var instructionText = new Text2('Find the exit!', {
size: 40,
fill: 0xFFFFFF
});
instructionText.anchor.set(0.5, 0);
instructionText.y = 80;
LK.gui.top.addChild(instructionText);
var roomText = new Text2('Room 1', {
size: 50,
fill: 0xFFFF00
});
roomText.anchor.set(0.5, 0);
roomText.y = 140;
LK.gui.top.addChild(roomText);
// Control arrows
var forwardArrow = new Text2('↑', {
size: 120,
fill: 0xFFFFFF
});
forwardArrow.anchor.set(0.5, 0.5);
forwardArrow.alpha = 0.7;
LK.gui.bottomLeft.addChild(forwardArrow);
forwardArrow.x = 150;
forwardArrow.y = -150;
var leftArrow = new Text2('←', {
size: 120,
fill: 0xFFFFFF
});
leftArrow.anchor.set(0.5, 0.5);
leftArrow.alpha = 0.7;
LK.gui.bottomRight.addChild(leftArrow);
leftArrow.x = -300;
leftArrow.y = -150;
var rightArrow = new Text2('→', {
size: 120,
fill: 0xFFFFFF
});
rightArrow.anchor.set(0.5, 0.5);
rightArrow.alpha = 0.7;
LK.gui.bottomRight.addChild(rightArrow);
rightArrow.x = -150;
rightArrow.y = -150;
// Initialize first level
function initLevel() {
var mazeSize = 25; // Fixed size for room-based design
maze = mazeGenerator.generate(mazeSize, mazeSize);
// Set player starting position
playerX = maze.startX + 0.5;
playerY = maze.startY + 0.5;
playerAngle = 0;
maze.currentRoom = 0;
// Setup minimap
minimap.setup(maze);
minimap.x = 2048 - maze.width * minimap.cellSize - 50;
minimap.y = 50;
game.addChild(minimap);
// Update UI
levelText.setText('Level: ' + currentLevel);
roomText.setText('Room 1');
instructionText.setText('Find the exit!');
}
// Control functions
function handleMovement() {
var newX = playerX;
var newY = playerY;
if (moveForward) {
newX += Math.cos(playerAngle) * moveSpeed;
newY += Math.sin(playerAngle) * moveSpeed;
}
if (moveBackward) {
newX -= Math.cos(playerAngle) * moveSpeed;
newY -= Math.sin(playerAngle) * moveSpeed;
}
// Collision detection
var mapX = Math.floor(newX);
var mapY = Math.floor(newY);
if (mapX >= 0 && mapX < maze.width && mapY >= 0 && mapY < maze.height) {
if (maze.grid[mapY][mapX] !== 1) {
// Check for door interaction
if (maze.grid[mapY][mapX] === 3) {
// Door found - flash green and allow passage
LK.effects.flashScreen(0x00FF00, 200);
maze.grid[mapY][mapX] = 0; // Open the door
instructionText.setText('Door opened!');
LK.setTimeout(function () {
instructionText.setText('Find the exit!');
}, 1000);
}
playerX = newX;
playerY = newY;
// Update current room display
if (maze.rooms) {
for (var r = 0; r < maze.rooms.length; r++) {
var room = maze.rooms[r];
if (mapX >= room.x && mapX < room.x + room.width && mapY >= room.y && mapY < room.y + room.height) {
if (maze.currentRoom !== r) {
maze.currentRoom = r;
roomText.setText('Room ' + (r + 1));
LK.effects.flashScreen(0x0000FF, 300);
}
break;
}
}
}
// Check if reached exit
if (maze.grid[mapY][mapX] === 2) {
completeLevel();
}
}
}
if (turnLeft) {
playerAngle -= turnSpeed;
}
if (turnRight) {
playerAngle += turnSpeed;
}
// Normalize angle
while (playerAngle < 0) playerAngle += Math.PI * 2;
while (playerAngle >= Math.PI * 2) playerAngle -= Math.PI * 2;
}
function completeLevel() {
LK.getSound('complete').play();
LK.setScore(currentLevel);
currentLevel++;
storage.currentLevel = currentLevel;
if (currentLevel > 10) {
LK.showYouWin();
} else {
// Flash effect and move to next level
LK.effects.flashScreen(0x00FF00, 500);
LK.setTimeout(function () {
initLevel();
}, 500);
}
}
// Arrow control event handlers
forwardArrow.down = function (x, y, obj) {
moveForward = true;
forwardArrow.alpha = 1.0;
};
forwardArrow.up = function (x, y, obj) {
moveForward = false;
forwardArrow.alpha = 0.7;
};
leftArrow.down = function (x, y, obj) {
turnLeft = true;
leftArrow.alpha = 1.0;
};
leftArrow.up = function (x, y, obj) {
turnLeft = false;
leftArrow.alpha = 0.7;
};
rightArrow.down = function (x, y, obj) {
turnRight = true;
rightArrow.alpha = 1.0;
};
rightArrow.up = function (x, y, obj) {
turnRight = false;
rightArrow.alpha = 0.7;
};
// Touch event handlers
game.down = function (x, y, obj) {
isTouching = true;
touchStartX = x;
touchStartY = y;
};
game.move = function (x, y, obj) {
if (!isTouching) return;
var deltaX = x - touchStartX;
var deltaY = y - touchStartY;
// Reset movement flags
moveForward = false;
moveBackward = false;
turnLeft = false;
turnRight = false;
// Determine movement based on touch direction
if (Math.abs(deltaY) > Math.abs(deltaX)) {
// Vertical movement
if (deltaY < -30) {
moveForward = true;
} else if (deltaY > 30) {
moveBackward = true;
}
} else {
// Horizontal movement
if (deltaX < -30) {
turnLeft = true;
} else if (deltaX > 30) {
turnRight = true;
}
}
};
game.up = function (x, y, obj) {
isTouching = false;
moveForward = false;
moveBackward = false;
turnLeft = false;
turnRight = false;
};
// Add renderer to game
game.addChild(raycastRenderer);
raycastRenderer.x = 0;
raycastRenderer.y = 0;
// Main game loop
var lastRenderTime = 0;
var renderInterval = 33; // ~30fps to reduce load
game.update = function () {
if (maze) {
handleMovement();
// Only render raycast every few frames to improve performance
if (LK.ticks - lastRenderTime >= 2) {
raycastRenderer.render(playerX, playerY, playerAngle, maze);
lastRenderTime = LK.ticks;
}
minimap.updatePlayer(playerX, playerY);
}
};
// Start the game
initLevel(); ===================================================================
--- original.js
+++ change.js
@@ -16,113 +16,80 @@
grid: [],
startX: 1,
startY: 1,
endX: width - 2,
- endY: height - 2
+ endY: height - 2,
+ rooms: [],
+ currentRoom: 0
};
// Initialize maze with walls
for (var y = 0; y < height; y++) {
maze.grid[y] = [];
for (var x = 0; x < width; x++) {
maze.grid[y][x] = 1; // Wall
}
}
- // Simple maze generation using recursive backtracking
- self.carvePath(maze, 1, 1);
- // Create rooms with doors
- self.createRooms(maze);
+ // Create linear sequence of rooms like Doors game
+ self.createLinearRooms(maze);
// Ensure start and end are open
maze.grid[maze.startY][maze.startX] = 0;
maze.grid[maze.endY][maze.endX] = 2; // Exit
return maze;
};
- self.carvePath = function (maze, x, y) {
- maze.grid[y][x] = 0; // Open path
- var directions = [{
- dx: 0,
- dy: -2
- },
- // Up
- {
- dx: 2,
- dy: 0
- },
- // Right
- {
- dx: 0,
- dy: 2
- },
- // Down
- {
- dx: -2,
- dy: 0
- } // Left
- ];
- // Shuffle directions
- for (var i = directions.length - 1; i > 0; i--) {
- var j = Math.floor(Math.random() * (i + 1));
- var temp = directions[i];
- directions[i] = directions[j];
- directions[j] = temp;
- }
- for (var i = 0; i < directions.length; i++) {
- var newX = x + directions[i].dx;
- var newY = y + directions[i].dy;
- if (newX > 0 && newX < maze.width - 1 && newY > 0 && newY < maze.height - 1 && maze.grid[newY][newX] === 1) {
- // Carve wall between current and new position
- maze.grid[y + directions[i].dy / 2][x + directions[i].dx / 2] = 0;
- self.carvePath(maze, newX, newY);
- }
- }
- };
- self.createRooms = function (maze) {
- // Create 2-4 rooms in the maze
- var roomCount = 2 + Math.floor(Math.random() * 3);
+ self.createLinearRooms = function (maze) {
+ // Create a linear sequence of rooms connected by doors (like Doors game)
+ var roomCount = 3 + Math.floor(Math.random() * 2); // 3-4 rooms
+ var roomWidth = 5;
+ var roomHeight = 5;
+ var hallwayWidth = 3;
+ // Calculate total width needed
+ var totalWidth = roomCount * roomWidth + (roomCount - 1) * hallwayWidth;
+ var startX = Math.floor((maze.width - totalWidth) / 2);
+ var startY = Math.floor((maze.height - roomHeight) / 2);
+ maze.rooms = [];
+ // Create rooms and connecting hallways
for (var r = 0; r < roomCount; r++) {
- var roomWidth = 3 + Math.floor(Math.random() * 3);
- var roomHeight = 3 + Math.floor(Math.random() * 3);
- var roomX = 2 + Math.floor(Math.random() * (maze.width - roomWidth - 4));
- var roomY = 2 + Math.floor(Math.random() * (maze.height - roomHeight - 4));
+ var roomX = startX + r * (roomWidth + hallwayWidth);
+ var roomY = startY;
+ // Store room info
+ maze.rooms.push({
+ x: roomX,
+ y: roomY,
+ width: roomWidth,
+ height: roomHeight,
+ number: r + 1
+ });
// Clear room area
for (var y = roomY; y < roomY + roomHeight; y++) {
for (var x = roomX; x < roomX + roomWidth; x++) {
if (x < maze.width && y < maze.height) {
maze.grid[y][x] = 0;
}
}
}
- // Add doors to room walls
- var doorCount = 1 + Math.floor(Math.random() * 2);
- for (var d = 0; d < doorCount; d++) {
- var side = Math.floor(Math.random() * 4);
- var doorX, doorY;
- switch (side) {
- case 0:
- // Top
- doorX = roomX + 1 + Math.floor(Math.random() * (roomWidth - 2));
- doorY = roomY - 1;
- break;
- case 1:
- // Right
- doorX = roomX + roomWidth;
- doorY = roomY + 1 + Math.floor(Math.random() * (roomHeight - 2));
- break;
- case 2:
- // Bottom
- doorX = roomX + 1 + Math.floor(Math.random() * (roomWidth - 2));
- doorY = roomY + roomHeight;
- break;
- case 3:
- // Left
- doorX = roomX - 1;
- doorY = roomY + 1 + Math.floor(Math.random() * (roomHeight - 2));
- break;
+ // Add door to next room (except for last room)
+ if (r < roomCount - 1) {
+ var doorX = roomX + roomWidth;
+ var doorY = roomY + Math.floor(roomHeight / 2);
+ // Create hallway to next room
+ for (var h = 0; h < hallwayWidth; h++) {
+ if (doorX + h < maze.width) {
+ maze.grid[doorY][doorX + h] = 0;
+ }
}
- if (doorX >= 0 && doorX < maze.width && doorY >= 0 && doorY < maze.height) {
- maze.grid[doorY][doorX] = 3; // Door
+ // Place door at end of hallway
+ if (doorX + hallwayWidth - 1 < maze.width) {
+ maze.grid[doorY][doorX + hallwayWidth - 1] = 3; // Door
}
}
}
+ // Set start in first room
+ maze.startX = maze.rooms[0].x + 1;
+ maze.startY = maze.rooms[0].y + 1;
+ // Set exit in last room
+ var lastRoom = maze.rooms[maze.rooms.length - 1];
+ maze.endX = lastRoom.x + lastRoom.width - 2;
+ maze.endY = lastRoom.y + lastRoom.height - 2;
};
return self;
});
var Minimap = Container.expand(function () {
@@ -330,8 +297,15 @@
});
instructionText.anchor.set(0.5, 0);
instructionText.y = 80;
LK.gui.top.addChild(instructionText);
+var roomText = new Text2('Room 1', {
+ size: 50,
+ fill: 0xFFFF00
+});
+roomText.anchor.set(0.5, 0);
+roomText.y = 140;
+LK.gui.top.addChild(roomText);
// Control arrows
var forwardArrow = new Text2('↑', {
size: 120,
fill: 0xFFFFFF
@@ -360,22 +334,24 @@
rightArrow.x = -150;
rightArrow.y = -150;
// Initialize first level
function initLevel() {
- var mazeSize = 11 + (currentLevel - 1) * 2; // Increasing maze size
- if (mazeSize > 21) mazeSize = 21; // Cap maze size
+ var mazeSize = 25; // Fixed size for room-based design
maze = mazeGenerator.generate(mazeSize, mazeSize);
// Set player starting position
playerX = maze.startX + 0.5;
playerY = maze.startY + 0.5;
playerAngle = 0;
+ maze.currentRoom = 0;
// Setup minimap
minimap.setup(maze);
minimap.x = 2048 - maze.width * minimap.cellSize - 50;
minimap.y = 50;
game.addChild(minimap);
// Update UI
levelText.setText('Level: ' + currentLevel);
+ roomText.setText('Room 1');
+ instructionText.setText('Find the exit!');
}
// Control functions
function handleMovement() {
var newX = playerX;
@@ -392,10 +368,34 @@
var mapX = Math.floor(newX);
var mapY = Math.floor(newY);
if (mapX >= 0 && mapX < maze.width && mapY >= 0 && mapY < maze.height) {
if (maze.grid[mapY][mapX] !== 1) {
+ // Check for door interaction
+ if (maze.grid[mapY][mapX] === 3) {
+ // Door found - flash green and allow passage
+ LK.effects.flashScreen(0x00FF00, 200);
+ maze.grid[mapY][mapX] = 0; // Open the door
+ instructionText.setText('Door opened!');
+ LK.setTimeout(function () {
+ instructionText.setText('Find the exit!');
+ }, 1000);
+ }
playerX = newX;
playerY = newY;
+ // Update current room display
+ if (maze.rooms) {
+ for (var r = 0; r < maze.rooms.length; r++) {
+ var room = maze.rooms[r];
+ if (mapX >= room.x && mapX < room.x + room.width && mapY >= room.y && mapY < room.y + room.height) {
+ if (maze.currentRoom !== r) {
+ maze.currentRoom = r;
+ roomText.setText('Room ' + (r + 1));
+ LK.effects.flashScreen(0x0000FF, 300);
+ }
+ break;
+ }
+ }
+ }
// Check if reached exit
if (maze.grid[mapY][mapX] === 2) {
completeLevel();
}
Showing 1 to 19 of 19
Used plugins
@upit/tween@upit/storage
