backrooms

 Players = :()
 UserInputService = :()
 SoundService = :()
 Workspace = :()
 Lighting = :()
 RunService = :()
 CollectionService = :()

 player = Players.LocalPlayer
 playerGui = player:()


 START_SOUND_ID = 
 BUTTON_SOUND_ID = 
 BACKROOMS_SOUND_ID = 
 ENTITY_SOUND_ID = 
 ATTACK_SOUND_ID = 


  (soundId, volume)
    volume = volume  
     sound = .()
    sound.SoundId =  .. soundId
    sound.Volume = volume
    sound.Parent = SoundService
    sound:()
    
    sound.Ended:(()
        sound:()
    )



(START_SOUND_ID)


 screenGui = .()
screenGui.Name = 
screenGui.ResetOnSpawn = 
screenGui.ZIndexBehavior = .ZIndexBehavior.Sibling
screenGui.Parent = playerGui


 mainFrame = .()
mainFrame.Name = 
mainFrame.Size = .(, , , )
mainFrame.Position = .(, , , )
mainFrame.BackgroundColor3 = .(, , )
mainFrame.BorderSizePixel = 
mainFrame.BackgroundTransparency = 
mainFrame.Parent = screenGui


 corner = .()
corner.CornerRadius = .(, )
corner.Parent = mainFrame


 border = .()
border.Color = .(, , )
border.Thickness = 
border.Parent = mainFrame


 title = .()
title.Name = 
title.Size = .(, , , )
title.Position = .(, , , )
title.BackgroundColor3 = .(, , )
title.TextColor3 = .(, , )
title.Text = 
title.Font = .Font.GothamBold
title.TextSize = 
title.Parent = mainFrame

 titleCorner = .()
titleCorner.CornerRadius = .(, )
titleCorner.Parent = title


 controlContainer = .()
controlContainer.Name = 
controlContainer.Size = .(, -, , )
controlContainer.Position = .(, , , -)
controlContainer.BackgroundTransparency = 
controlContainer.Parent = mainFrame


 controlLayout = .()
controlLayout.CellSize = .(, -, , )
controlLayout.CellPadding = .(, , , )
controlLayout.HorizontalAlignment = .HorizontalAlignment.Center
controlLayout.Parent = controlContainer


 toggleButton = .()
toggleButton.Name = 
toggleButton.Size = .(, , , )
toggleButton.BackgroundColor3 = .(, , )
toggleButton.TextColor3 = .(, , )
toggleButton.Text = 
toggleButton.Font = .Font.Gotham
toggleButton.TextSize = 
toggleButton.Parent = controlContainer

 toggleCorner = .()
toggleCorner.CornerRadius = .(, )
toggleCorner.Parent = toggleButton


 pinButton = .()
pinButton.Name = 
pinButton.Size = .(, , , )
pinButton.BackgroundColor3 = .(, , )
pinButton.TextColor3 = .(, , )
pinButton.Text = 
pinButton.Font = .Font.Gotham
pinButton.TextSize = 
pinButton.Parent = controlContainer

 pinCorner = .()
pinCorner.CornerRadius = .(, )
pinCorner.Parent = pinButton


 buttonContainer = .()
buttonContainer.Name = 
buttonContainer.Size = .(, -, , -)
buttonContainer.Position = .(, , , )
buttonContainer.BackgroundTransparency = 
buttonContainer.Visible = 
buttonContainer.Parent = mainFrame


 layout = .()
layout.Padding = .(, )
layout.HorizontalAlignment = .HorizontalAlignment.Center
layout.VerticalAlignment = .VerticalAlignment.Top
layout.Parent = buttonContainer


 (text, color, height)
    height = height  
     button = .()
    button.Name = text .. 
    button.Size = .(, , , height)
    button.BackgroundColor3 = color
    button.TextColor3 = .(, , )
    button.Text = text
    button.Font = .Font.GothamMedium
    button.TextSize = 
    button.AutoButtonColor = 
    
     buttonCorner = .()
    buttonCorner.CornerRadius = .(, )
    buttonCorner.Parent = button
    
     button



  (width, height)
     maze = {}
     x = , width 
        maze[x] = {}
         y = , height 
            maze[x][y] = 
        
    
    
     stack = {}
     startX, startY = , 
    
    maze[startX][startY] = 
    .(stack, {x = startX, y = startY})
    
     directions = {
        {dx = , dy = },
        {dx = -, dy = },
        {dx = , dy = },
        {dx = , dy = -}
    }
    
     #stack >  
         current = stack[#stack]
         available = {}
        
         _, dir  (directions) 
             nx, ny = current.x + dir.dx, current.y + dir.dy
             nx >=   nx <= width  ny >=   ny <= height  maze[nx][ny] ==  
                 wallX, wallY = current.x + dir.dx/, current.y + dir.dy/
                 maze[wallX]  maze[wallX][wallY] ==  
                    .(available, {dx = dir.dx, dy = dir.dy})
                
            
        
        
         #available >  
             chosen = available[.(, #available)]
             wallX, wallY = current.x + chosen.dx/, current.y + chosen.dy/
             newX, newY = current.x + chosen.dx, current.y + chosen.dy
            
            maze[wallX][wallY] = 
            maze[newX][newY] = 
            
            .(stack, {x = newX, y = newY})
        
            .(stack)
        
    
    
    maze[][] = 
    maze[width][height-] = 
    
     maze



 entities = {}
 entityConnections = {}


  (position, color, speed, aggression)
     entityFolder = Workspace:()
      entityFolder    
    
     model = .()
    model.Name =  .. #entities + 
    model.Parent = entityFolder
    
     mainPart = .()
    mainPart.Name = 
    mainPart.Size = .(, , )
    mainPart.Position = position
    mainPart.Anchored = 
    mainPart.CanCollide = 
    mainPart.Material = .Material.SmoothPlastic
    mainPart.Color = color  .(, , )
    mainPart.BrickColor = BrickColor.()
    mainPart.BottomSurface = .SurfaceType.Smooth
    mainPart.TopSurface = .SurfaceType.Smooth
    mainPart.Parent = model
    
     light = .(, mainPart)
    light.Brightness = 
    light.Range = 
    light.Color = color  .(, , )
    light.Shadows = 
    
     head = .()
    head.Name = 
    head.Size = .(, , )
    head.Position = position + .(, , )
    head.Anchored = 
    head.CanCollide = 
    head.Material = .Material.Glass
    head.Color = .(, , )
    head.Transparency = 
    head.BrickColor = BrickColor.()
    head.Parent = model
    
     eye1 = .()
    eye1.Name = 
    eye1.Size = .(, , )
    eye1.Position = position + .(-, , )
    eye1.Anchored = 
    eye1.CanCollide = 
    eye1.Material = .Material.Neon
    eye1.Color = .(, , )
    eye1.Parent = model
    
     eye2 = .()
    eye2.Name = 
    eye2.Size = .(, , )
    eye2.Position = position + .(, , )
    eye2.Anchored = 
    eye2.CanCollide = 
    eye2.Material = .Material.Neon
    eye2.Color = .(, , )
    eye2.Parent = model
    
     i = -, ,  
         arm = .()
        arm.Name =  .. ((i + ) / )
        arm.Size = .(, , )
        arm.Position = position + .(i * , , )
        arm.Anchored = 
        arm.CanCollide = 
        arm.Material = .Material.SmoothPlastic
        arm.Color = .(, , )
        arm.Parent = model
    
    
     weld1 = .()
    weld1.Name = 
    weld1.Part0 = mainPart
    weld1.Part1 = head
    weld1.C0 = .(, , )
    weld1.Parent = mainPart
    
     weld2 = .()
    weld2.Name = 
    weld2.Part0 = head
    weld2.Part1 = eye1
    weld2.C0 = .(-, , )
    weld2.Parent = head
    
     weld3 = .()
    weld3.Name = 
    weld3.Part0 = head
    weld3.Part1 = eye2
    weld3.C0 = .(, , )
    weld3.Parent = head
    
     weld4 = .()
    weld4.Name = 
    weld4.Part0 = mainPart
    weld4.Part1 = model:()
    weld4.C0 = .(-, -, )
    weld4.Parent = mainPart
    
     weld5 = .()
    weld5.Name = 
    weld5.Part0 = mainPart
    weld5.Part1 = model:()
    weld5.C0 = .(, -, )
    weld5.Parent = mainPart
    
     sound = .()
    sound.Name = 
    sound.SoundId =  .. ENTITY_SOUND_ID
    sound.Looped = 
    sound.Volume = 
    sound.Parent = model
    sound:()
    
     entityData = {
        model = model,
        mainPart = mainPart,
        speed = speed  ,
        aggression = aggression  ,
        state = ,
        target = ,
        lastAttack = ,
        attackCooldown = ,
        color = color,
        position = position
    }
    
    .(entities, entityData)
    CollectionService:(model, )
    
     entityData



  (dt)
     character = player.Character
      character   
    
     humanoidRootPart = character:()
      humanoidRootPart   
    
     playerPos = humanoidRootPart.Position
    
     i, entity  (entities) 
         entity.model  entity.model.Parent 
             entityPos = entity.mainPart.Position
             distance = (playerPos - entityPos).Magnitude
            
             distance <  
                entity.state = 
                entity.target = playerPos
                
                 direction = (playerPos - entityPos).Unit
                 newPos = entityPos + direction * entity.speed * dt
                
                entity.mainPart.CFrame = .(newPos, playerPos) * .(, .pi, )
                
                 distance <  
                     now = ()
                     now - entity.lastAttack > entity.attackCooldown 
                        entity.state = 
                        entity.lastAttack = now
                        
                        (ATTACK_SOUND_ID, )
                        
                         flash = .()
                        flash.Name = 
                        flash.Size = .(, , )
                        flash.Position = entityPos
                        flash.Anchored = 
                        flash.CanCollide = 
                        flash.Material = .Material.Neon
                        flash.Color = .(, , )
                        flash.Transparency = 
                        flash.Parent = Workspace
                        
                        :():(flash, TweenInfo.(), {Transparency = }):()
                        .()
                        flash:()
                        
                         character  character:() 
                            character.Humanoid.Health = 
                        
                        
                        entity.state = 
                    
                
                
                 entity.state ==  
                     t = .(() * ) *  + 
                    entity.mainPart.Color = .( + t * , , )
                
            
                entity.state = 
                 .() <  
                    entity.mainPart.CFrame = entity.mainPart.CFrame * .(, .() * .pi * , )
                
                entity.mainPart.Color = .(, , )
            
        
            .(entities, i)
        
    



  ()
     i, entity  (entities) 
         entity.model  entity.model.Parent 
            entity.model:()
        
    
    entities = {}



 BASE_POSITION = .(, , )


  (floorY, roomHeight, backroomsFolder, roomWidth, roomLength)
     anomalies = {}
     halfWidth = roomWidth / 
     halfLength = roomLength / 
    
    
     i = ,  
         angle = .() * .pi * 
        
         radius = .(, halfWidth - )
         size =  + .(, )
        
         anomalyPos = .(
            BASE_POSITION.X + .(angle) * radius,
            floorY,
            BASE_POSITION.Z + .(angle) * radius
        )
        
        
        anomalyPos = .(
            .(anomalyPos.X, -halfWidth + size/ + , halfWidth - size/ - ),
            floorY,
            .(anomalyPos.Z, -halfLength + size/ + , halfLength - size/ - )
        )
        
        
         marker = .()
        marker.Name =  .. i
        marker.Size = .(size, , size)
        marker.Position = anomalyPos + .(, roomHeight/, )
        marker.Anchored = 
        marker.CanCollide = 
        marker.Transparency = 
        marker.Material = .Material.Neon
        marker.Color = .(, , )
        marker.Parent = backroomsFolder
        
        
         beam = .()
        beam.Name =  .. i
        beam.Size = .(size/, , size/)
        beam.Position = anomalyPos + .(, roomHeight + , )
        beam.Anchored = 
        beam.CanCollide = 
        beam.Transparency = 
        beam.Material = .Material.Neon
        beam.Color = .(, , )
        beam.Parent = backroomsFolder
        
        .(anomalies, { = , position = anomalyPos, size = size})
    
    
    
     i = ,  
         angle = .() * .pi * 
         radius = .(, halfWidth - )
         size =  + .(, )
        
         anomalyPos = .(
            BASE_POSITION.X + .(angle) * radius,
            floorY,
            BASE_POSITION.Z + .(angle) * radius
        )
        
        anomalyPos = .(
            .(anomalyPos.X, -halfWidth + size/ + , halfWidth - size/ - ),
            floorY,
            .(anomalyPos.Z, -halfLength + size/ + , halfLength - size/ - )
        )
        
        
         redFloor = .()
        redFloor.Name =  .. i
        redFloor.Size = .(size, , size)
        redFloor.Position = anomalyPos
        redFloor.Anchored = 
        redFloor.CanCollide = 
        redFloor.Material = .Material.Neon
        redFloor.Color = .(, , )
        redFloor.Parent = backroomsFolder
        
        
         wallSize = 
         wallPositions = {
            .(size/, roomHeight/, ),
            .(-size/, roomHeight/, ),
            .(, roomHeight/, size/),
            .(, roomHeight/, -size/)
        }
        
         _, offset  (wallPositions) 
             wall = .()
            wall.Name =  .. i
            wall.Size = .(size, roomHeight, wallSize)
            wall.Position = anomalyPos + offset
            wall.Anchored = 
            wall.CanCollide = 
            wall.Material = .Material.Neon
            wall.Color = .(, , )
            wall.Transparency = 
            wall.Parent = backroomsFolder
        
        
         redLight = .()
        redLight.Parent = redFloor
        redLight.Brightness = 
        redLight.Range = size
        redLight.Color = .(, , )
        
        .(anomalies, { = , position = anomalyPos, size = size})
    
    
    
     i = ,  
         angle = .() * .pi * 
         radius = .(, halfWidth - )
         size =  + .(, )
        
         anomalyPos = .(
            BASE_POSITION.X + .(angle) * radius,
            floorY,
            BASE_POSITION.Z + .(angle) * radius
        )
        
        anomalyPos = .(
            .(anomalyPos.X, -halfWidth + size/ + , halfWidth - size/ - ),
            floorY,
            .(anomalyPos.Z, -halfLength + size/ + , halfLength - size/ - )
        )
        
         blueFloor = .()
        blueFloor.Name =  .. i
        blueFloor.Size = .(size, , size)
        blueFloor.Position = anomalyPos
        blueFloor.Anchored = 
        blueFloor.CanCollide = 
        blueFloor.Material = .Material.Neon
        blueFloor.Color = .(, , )
        blueFloor.Parent = backroomsFolder
        
         blueLight = .()
        blueLight.Parent = blueFloor
        blueLight.Brightness = 
        blueLight.Range = size
        blueLight.Color = .(, , )
        
        .(anomalies, { = , position = anomalyPos, size = size})
    
    
    
     i = ,  
         angle = .() * .pi * 
         radius = .(, halfWidth - )
         size =  + .(, )
        
         anomalyPos = .(
            BASE_POSITION.X + .(angle) * radius,
            floorY,
            BASE_POSITION.Z + .(angle) * radius
        )
        
        anomalyPos = .(
            .(anomalyPos.X, -halfWidth + size/ + , halfWidth - size/ - ),
            floorY,
            .(anomalyPos.Z, -halfLength + size/ + , halfLength - size/ - )
        )
        
         blackFloor = .()
        blackFloor.Name =  .. i
        blackFloor.Size = .(size, , size)
        blackFloor.Position = anomalyPos
        blackFloor.Anchored = 
        blackFloor.CanCollide = 
        blackFloor.Material = .Material.Slate
        blackFloor.Color = .(, , )
        blackFloor.BrickColor = BrickColor.()
        blackFloor.Parent = backroomsFolder
        
         j = ,  
             blackWall = .()
            blackWall.Name =  .. i ..  .. j
            blackWall.Size = .(size + , roomHeight, )
            blackWall.CFrame = .(anomalyPos) * .(, (j-) * .pi/, ) * .(, , size/ + )
            blackWall.Anchored = 
            blackWall.CanCollide = 
            blackWall.Material = .Material.Slate
            blackWall.Color = .(, , )
            blackWall.BrickColor = BrickColor.()
            blackWall.Parent = backroomsFolder
        
        
        .(anomalies, { = , position = anomalyPos, size = size})
    
    
    
     i = ,  
         angle = .() * .pi * 
         radius = .(, halfWidth - )
         length =  + .(, )
        
         startPos = .(
            BASE_POSITION.X + .(angle) * radius,
            floorY,
            BASE_POSITION.Z + .(angle) * radius
        )
        
        startPos = .(
            .(startPos.X, -halfWidth + , halfWidth - ),
            floorY,
            .(startPos.Z, -halfLength + , halfLength - )
        )
        
         endPos = startPos + .(.(angle + .pi/) * length, , .(angle + .pi/) * length)
        endPos = .(
            .(endPos.X, -halfWidth + , halfWidth - ),
            floorY,
            .(endPos.Z, -halfLength + , halfLength - )
        )
        
         j = , .(length / ) 
             t = j / (length / )
             pos = startPos:(endPos, t)
            
             corridor = .()
            corridor.Name =  .. i ..  .. j
            corridor.Size = .(, roomHeight * , )
            corridor.Position = pos + .(, roomHeight, )
            corridor.Anchored = 
            corridor.CanCollide = 
            corridor.Material = .Material.Plastic
            corridor.Color = .(, , )
            corridor.Parent = backroomsFolder
        
        
        .(anomalies, { = , position = startPos, length = length})
    
    
     anomalies



  (floorY, backroomsFolder, roomWidth, roomLength)
    ()
    
     halfWidth = roomWidth / 
     halfLength = roomLength / 
     entityCount =   
    
     i = , entityCount 
         angle = .() * .pi * 
         radius = .(, )  
        
         pos = .(
            BASE_POSITION.X + .(angle) * radius,
            floorY + ,
            BASE_POSITION.Z + .(angle) * radius
        )
        
        
        pos = .(
            .(pos.X, -halfWidth + , halfWidth - ),
            floorY + ,
            .(pos.Z, -halfLength + , halfLength - )
        )
        
         colorChoice = .(, )
         color
         colorChoice ==  
            color = .(, , )
         colorChoice ==  
            color = .(, , )
        
            color = .(, , )
        
        
         speed =  + .(, )
         aggression =  + .() * 
        
        (pos, color, speed, aggression)
    
    
     entityCount



  ()
    
     existingFolder = Workspace:()
     existingFolder 
        existingFolder:()
    
    
    ()
    
     atmosphere = Workspace:()
     atmosphere 
        atmosphere:()
    
    
    
     backroomsFolder = .(, Workspace)
    backroomsFolder.Name = 
    
    
    Lighting.Ambient = .(, , )
    Lighting.Brightness = 
    Lighting.Outlines = 
    
    
     roomWidth = 
     roomLength =  
     roomHeight = 
     halfWidth = roomWidth / 
     halfLength = roomLength / 
    
    
     floorY = BASE_POSITION.Y - roomHeight/ + 
    
    
     floorSegments =   
     segmentWidth = roomWidth / floorSegments
     segmentLength = roomLength / floorSegments
    
     sx = , floorSegments -  
         sz = , floorSegments -  
             floor = .(, backroomsFolder)
            floor.Name = .(, sx, sz)
            floor.Size = .(segmentWidth + , , segmentLength + )  
            floor.Position = .(
                BASE_POSITION.X - halfWidth + segmentWidth/ + sx * segmentWidth,
                floorY,
                BASE_POSITION.Z - halfLength + segmentLength/ + sz * segmentLength
            )
            floor.Anchored = 
            floor.CanCollide = 
            floor.Material = .Material.Fabric
            floor.Color = .(, , )
        
    
    
    
     sx = , floorSegments -  
         sz = , floorSegments -  
             ceiling = .(, backroomsFolder)
            ceiling.Name = .(, sx, sz)
            ceiling.Size = .(segmentWidth + , , segmentLength + )
            ceiling.Position = .(
                BASE_POSITION.X - halfWidth + segmentWidth/ + sx * segmentWidth,
                floorY + roomHeight - ,
                BASE_POSITION.Z - halfLength + segmentLength/ + sz * segmentLength
            )
            ceiling.Anchored = 
            ceiling.CanCollide = 
            ceiling.Material = .Material.Plastic
            ceiling.Color = .(, , )
            ceiling.Transparency = 
        
    
    
    
     wallThickness = 
    
    
     sx = , floorSegments -  
         northWall = .(, backroomsFolder)
        northWall.Name =  .. sx
        northWall.Size = .(segmentWidth + , roomHeight, wallThickness)
        northWall.Position = .(
            BASE_POSITION.X - halfWidth + segmentWidth/ + sx * segmentWidth,
            floorY + roomHeight/,
            BASE_POSITION.Z + halfLength
        )
        northWall.Anchored = 
        northWall.CanCollide = 
        northWall.Material = .Material.Plastic
        northWall.Color = .(, , )
    
    
    
     sx = , floorSegments -  
         southWall = .(, backroomsFolder)
        southWall.Name =  .. sx
        southWall.Size = .(segmentWidth + , roomHeight, wallThickness)
        southWall.Position = .(
            BASE_POSITION.X - halfWidth + segmentWidth/ + sx * segmentWidth,
            floorY + roomHeight/,
            BASE_POSITION.Z - halfLength
        )
        southWall.Anchored = 
        southWall.CanCollide = 
        southWall.Material = .Material.Plastic
        southWall.Color = .(, , )
    
    
    
     sz = , floorSegments -  
         eastWall = .(, backroomsFolder)
        eastWall.Name =  .. sz
        eastWall.Size = .(wallThickness, roomHeight, segmentLength + )
        eastWall.Position = .(
            BASE_POSITION.X + halfWidth,
            floorY + roomHeight/,
            BASE_POSITION.Z - halfLength + segmentLength/ + sz * segmentLength
        )
        eastWall.Anchored = 
        eastWall.CanCollide = 
        eastWall.Material = .Material.Plastic
        eastWall.Color = .(, , )
    
    
    
     sz = , floorSegments -  
         westWall = .(, backroomsFolder)
        westWall.Name =  .. sz
        westWall.Size = .(wallThickness, roomHeight, segmentLength + )
        westWall.Position = .(
            BASE_POSITION.X - halfWidth,
            floorY + roomHeight/,
            BASE_POSITION.Z - halfLength + segmentLength/ + sz * segmentLength
        )
        westWall.Anchored = 
        westWall.CanCollide = 
        westWall.Material = .Material.Plastic
        westWall.Color = .(, , )
    
    
    
     mazeWidth = 
     mazeHeight = 
     cellSize = 
    
     maze = (mazeWidth, mazeHeight)
     mazeFolder = .(, backroomsFolder)
    mazeFolder.Name = 
    
     mazeOffsetX = BASE_POSITION.X - 
     mazeOffsetZ = BASE_POSITION.Z - 
    
     x = , mazeWidth 
         y = , mazeHeight 
             maze[x][y] ==   (x %  ==   y %  == ) 
                 wallX = mazeOffsetX + (x - ) * cellSize
                 wallZ = mazeOffsetZ + (y - ) * cellSize
                
                
                 .(wallX) < halfWidth - cellSize  .(wallZ) < halfLength - cellSize 
                     wall = .(, mazeFolder)
                    wall.Name = .(, x, y)
                    wall.Size = .(cellSize, roomHeight - , cellSize)
                    wall.Position = .(
                        wallX,
                        floorY + (roomHeight - ) /  + ,
                        wallZ
                    )
                    wall.Anchored = 
                    wall.CanCollide = 
                    wall.Material = .Material.Plastic
                    wall.Color = .(, , )
                
            
        
    
    
    
     anomalies = (floorY, roomHeight, backroomsFolder, roomWidth, roomLength)
    
    
     entityCount = (floorY, backroomsFolder, roomWidth, roomLength)
    
    
     i = ,  
         roomSizeX =  + .(, )
         roomSizeZ =  + .(, )
        
         angle = .() * .pi * 
         radius = .(, )
        
         roomPos = .(
            BASE_POSITION.X + .(angle) * radius,
            floorY + (roomHeight - ) /  + ,
            BASE_POSITION.Z + .(angle) * radius
        )
        
        
        roomPos = .(
            .(roomPos.X, -halfWidth + roomSizeX/ + , halfWidth - roomSizeX/ - ),
            floorY + (roomHeight - ) /  + ,
            .(roomPos.Z, -halfLength + roomSizeZ/ + , halfLength - roomSizeZ/ - )
        )
        
         room = .(, backroomsFolder)
        room.Name =  .. i
        room.Size = .(roomSizeX, roomHeight - , roomSizeZ)
        room.Position = roomPos
        room.Anchored = 
        room.CanCollide = 
        room.Material = .Material.Plastic
        room.Color = .( + .(),  + .(),  + .())
    
    
    
     lightSpacing = 
     x = -halfWidth + , halfWidth - , lightSpacing 
         z = -halfLength + , halfLength - , lightSpacing 
             light = .(, backroomsFolder)
            light.Name = .(, x, z)
            light.Size = .(, , )
            light.Position = .(BASE_POSITION.X + x, floorY + roomHeight - , BASE_POSITION.Z + z)
            light.Anchored = 
            light.CanCollide = 
            light.Material = .Material.Neon
            light.Color = .(, , )
            
             pointLight = .(, light)
            pointLight.Brightness = 
            pointLight.Range = 
            pointLight.Color = .(, , )
        
    
    
    
     atmosphere = .(, Workspace)
    atmosphere.Name = 
    atmosphere.Density = 
    atmosphere.Color = .(, , )
    atmosphere.Decay = .(, , )
    atmosphere.Glare = 
    atmosphere.Haze = 
    
    
     soundFolder = .(, backroomsFolder)
    soundFolder.Name = 
    
     fanSound = .(, soundFolder)
    fanSound.Name = 
    fanSound.SoundId =  .. BACKROOMS_SOUND_ID
    fanSound.Looped = 
    fanSound.Volume = 
    fanSound:()
    
     horrorSound = .(, soundFolder)
    horrorSound.Name = 
    horrorSound.SoundId = 
    horrorSound.Looped = 
    horrorSound.Volume = 
    horrorSound:()
    
    
     character = player.Character
     character  character:() 
        character.HumanoidRootPart.CFrame = .(
            BASE_POSITION.X,
            floorY + ,
            BASE_POSITION.Z
        )
    
    
     {
        folder = backroomsFolder,
        width = roomWidth,
        length = roomLength,
        height = roomHeight,
        position = BASE_POSITION,
        entityCount = entityCount,
        anomalyCount = #anomalies
    }



  ()
     backroomsFolder = Workspace:()
     backroomsFolder 
        backroomsFolder:()
    
    
    ()
    
     atmosphere = Workspace:()
     atmosphere 
        atmosphere:()
    
    
    Lighting.Ambient = .(, , )
    Lighting.Brightness = 
    
     



 noclipButton = (, .(, , ), )
noclipButton.Parent = buttonContainer

 frontRoomButton = (, .(, , ), )
frontRoomButton.Parent = buttonContainer


 statusLabel = .()
statusLabel.Name = 
statusLabel.Size = .(, -, , )
statusLabel.Position = .(, , , -)
statusLabel.BackgroundTransparency = 
statusLabel.TextColor3 = .(, , )
statusLabel.Text = 
statusLabel.Font = .Font.Gotham
statusLabel.TextSize = 
statusLabel.TextWrapped = 
statusLabel.TextXAlignment = .TextXAlignment.Left
statusLabel.Parent = mainFrame


 isGUIPinned = 

  ()
    isGUIPinned =  isGUIPinned
    
     isGUIPinned 
        pinButton.Text = 
        pinButton.BackgroundColor3 = .(, , )
        statusLabel.Text = 
        statusLabel.TextColor3 = .(, , )
    
        pinButton.Text = 
        pinButton.BackgroundColor3 = .(, , )
        statusLabel.Text = 
        statusLabel.TextColor3 = .(, , )
    



RunService.Heartbeat:((dt)
    (dt)
)


noclipButton.MouseButton1Click:(()
    (BUTTON_SOUND_ID)
    
    statusLabel.Text = 
    statusLabel.TextColor3 = .(, , )
    
     success, result = (()
         ()
    )
    
     success 
         info = result
        statusLabel.Text = .(, 
            info.entityCount  , info.anomalyCount  )
        statusLabel.TextColor3 = .(, , )
        
        .()
        statusLabel.Text = 
    
        statusLabel.Text =  .. (result)
        statusLabel.TextColor3 = .(, , )
    
)


frontRoomButton.MouseButton1Click:(()
    (BUTTON_SOUND_ID)
    
     backroomsExists = Workspace:() ~= 
    
      backroomsExists 
        statusLabel.Text = 
        statusLabel.TextColor3 = .(, , )
        
    
    
    statusLabel.Text = 
    statusLabel.TextColor3 = .(, , )
    
     message = ()
    
    statusLabel.Text =  .. message
    statusLabel.TextColor3 = .(, , )
)


pinButton.MouseButton1Click:(()
    (BUTTON_SOUND_ID)
    ()
    statusLabel.Text = isGUIPinned    
    statusLabel.TextColor3 = .(, , )
)


toggleButton.MouseButton1Click:(()
    (BUTTON_SOUND_ID)
     buttonContainer.Visible 
        buttonContainer.Visible = 
        mainFrame.Size = .(, , , )
        toggleButton.Text = 
        statusLabel.Text = 
    
        buttonContainer.Visible = 
        mainFrame.Size = .(, , , )
        toggleButton.Text = 
        statusLabel.Text = isGUIPinned    
    
)


 dragging = 
 dragStart, startPos

  (input)
      isGUIPinned 
        dragging = 
        dragStart = input.Position
        startPos = mainFrame.Position
        
        input.Changed:(()
             input.UserInputState == .UserInputState.End 
                dragging = 
            
        )
    


  (input)
     dragging   isGUIPinned 
         delta = input.Position - dragStart
        mainFrame.Position = .(
            startPos.X.Scale, 
            startPos.X.Offset + delta.X, 
            startPos.Y.Scale, 
            startPos.Y.Offset + delta.Y
        )
    


title.InputBegan:((input)
     input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
        (input)
    
)

title.InputChanged:((input)
     input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch 
        (input)
    
)


statusLabel.Text = 
.()
statusLabel.Text =