boshy

local NPCDialogue = {}
NPCDialogue.__index = NPCDialogue

local TweenService = game:GetService("TweenService")
local Players = game:GetService("Players")

function NPCDialogue.new(dialogueData)
    local self = setmetatable({}, NPCDialogue)
    self.dialogueData = dialogueData
    self.currentNode = nil
    self.isActive = false
    self.ui = nil
    return self
end

function NPCDialogue:Start(player, startNode)
    if self.isActive then return end
    self.isActive = true
    self.currentNode = startNode or self.dialogueData.startNode
    self:ShowDialogue(player)
end

function NPCDialogue:ShowDialogue(player)
    -- Create and show UI
    self.ui = self:CreateDialogueUI()
    self:UpdateDialogueContent()
    self:AnimateUI()
end

function NPCDialogue:HandleChoice(choice)
    if not self.currentNode.choices then return end
    
    local nextNode = self.dialogueData.nodes[choice.nextNode]
    if nextNode then
        self.currentNode = nextNode
        self:UpdateDialogueContent()
    else
        self:End()
    end
end

function NPCDialogue:End()
    self.isActive = false
    if self.ui then
        self.ui:Destroy()
        self.ui = nil
    end
end

return NPCDialogue

local ChainReaction = {}
ChainReaction.__index = ChainReaction

local React = require(game.ReplicatedStorage.Packages.React)
local e = React.createElement

function ChainReaction.new(props)
    local self = setmetatable({}, ChainReaction)
    self.size = props.size or 5
    self.grid = {}
    self.moves = 0
    self:InitializeGrid()
    return self
end

function ChainReaction:InitializeGrid()
    for i = 1, self.size do
        self.grid[i] = {}
        for j = 1, self.size do
            self.grid[i][j] = false
        end
    end
end

function ChainReaction:ToggleCell(x, y)
    -- Toggle clicked cell and adjacent cells
    self:SetCell(x, y, not self.grid[x][y])
    self:SetCell(x+1, y, not self.grid[x+1][y])
    self:SetCell(x-1, y, not self.grid[x-1][y])
    self:SetCell(x, y+1, not self.grid[x][y+1])
    self:SetCell(x, y-1, not self.grid[x][y-1])
    
    self.moves = self.moves + 1
    self:CheckWinCondition()
end

function ChainReaction:SetCell(x, y, value)
    if x >= 1 and x <= self.size and y >= 1 and y <= self.size then
        self.grid[x][y] = value
    end
end

function ChainReaction:CheckWinCondition()
    for i = 1, self.size do
        for j = 1, self.size do
            if self.grid[i][j] then
                return false
            end
        end
    end
    return true
end

return ChainReaction

local DoorService = {}
DoorService.__index = DoorService

local Knit = require(game:GetService("ReplicatedStorage").Packages.Knit)
local Promise = require(game:GetService("ReplicatedStorage").Packages.Promise)

function DoorService:KnitStart()
    self.doors = {}
    self:InitializeDoors()
end

function DoorService:InitializeDoors()
    for _, door in ipairs(workspace.Doors:GetChildren()) do
        if door:IsA("Model") then
            self.doors[door.Name] = {
                instance = door,
                isLocked = door:GetAttribute("Locked") or false,
                isOpen = false,
                animation = door:FindFirstChild("AnimationController")
            }
        end
    end
end

function DoorService.Client:InteractWithDoor(player, doorName)
    return Promise.new(function(resolve, reject)
        local door = self.Server.doors[doorName]
        if not door then
            return reject("Door not found")
        end
        
        if door.isLocked then
            return reject("Door is locked")
        end
        
        -- Toggle door state
        door.isOpen = not door.isOpen
        self.Server:AnimateDoor(door)
        resolve(door.isOpen)
    end)
end

function DoorService:AnimateDoor(door)
    if door.animation then
        local track = door.animation:LoadAnimation(
            door.isOpen and self.openAnim or self.closeAnim
        )
        track:Play()
    end
end

return DoorService