Play
:quality(85)/https:%2F%2Fcdn.frvr.ai/68718cc00a62997a6828fccb.png)
:quality(85)/https:%2F%2Fcdn.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
};
// 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);
// 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);
}
}
};
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 {
// 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 = 128; // Number of rays to cast (reduced for performance)
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) {
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);
// Control arrows
var forwardArrow = new Text2('↑', {
size: 80,
fill: 0xFFFFFF
});
forwardArrow.anchor.set(0.5, 0.5);
forwardArrow.alpha = 0.7;
LK.gui.bottom.addChild(forwardArrow);
forwardArrow.y = -200;
var backwardArrow = new Text2('↓', {
size: 80,
fill: 0xFFFFFF
});
backwardArrow.anchor.set(0.5, 0.5);
backwardArrow.alpha = 0.7;
LK.gui.bottom.addChild(backwardArrow);
backwardArrow.y = -100;
var leftArrow = new Text2('←', {
size: 80,
fill: 0xFFFFFF
});
leftArrow.anchor.set(0.5, 0.5);
leftArrow.alpha = 0.7;
LK.gui.bottom.addChild(leftArrow);
leftArrow.x = -100;
leftArrow.y = -150;
var rightArrow = new Text2('→', {
size: 80,
fill: 0xFFFFFF
});
rightArrow.anchor.set(0.5, 0.5);
rightArrow.alpha = 0.7;
LK.gui.bottom.addChild(rightArrow);
rightArrow.x = 100;
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
maze = mazeGenerator.generate(mazeSize, mazeSize);
// Set player starting position
playerX = maze.startX + 0.5;
playerY = maze.startY + 0.5;
playerAngle = 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);
}
// 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) {
playerX = newX;
playerY = newY;
// 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;
};
backwardArrow.down = function (x, y, obj) {
moveBackward = true;
backwardArrow.alpha = 1.0;
};
backwardArrow.up = function (x, y, obj) {
moveBackward = false;
backwardArrow.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
@@ -147,53 +147,62 @@
});
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
- self.maxDistance = 20;
+ self.rayCount = 128; // Number of rays to cast (reduced for performance)
+ self.maxDistance = 15; // Reduced max distance
self.wallHeight = 300;
self.walls = [];
self.render = function (playerX, playerY, playerAngle, maze) {
- // Clear previous walls
- for (var i = 0; i < self.walls.length; i++) {
- self.walls[i].destroy();
+ // 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);
+ }
}
- self.walls = [];
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
- // Create wall segment
- var wall = LK.getAsset('raycast_wall', {
- width: 8,
- height: wallHeight,
- anchorX: 0,
- anchorY: 0.5
- });
- wall.x = i * 8;
- wall.y = 2732 / 2;
+ // 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);
- self.addChild(wall);
- self.walls.push(wall);
+ } else {
+ wall.visible = false;
}
rayAngle += angleStep;
}
};
self.castRay = function (x, y, angle, maze) {
- var dx = Math.cos(angle) * 0.05;
- var dy = Math.sin(angle) * 0.05;
+ var dx = Math.cos(angle) * 0.1;
+ var dy = Math.sin(angle) * 0.1;
var distance = 0;
- var stepSize = 0.05;
- while (distance < self.maxDistance) {
+ 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;
@@ -440,12 +449,18 @@
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();
- raycastRenderer.render(playerX, playerY, playerAngle, maze);
+ // 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
Showing 1 to 19 of 19
Used plugins
@upit/tween@upit/storage
