Hiddengate

local term = require("term")
local component = require("component")
local modem = component.modem
local reds = component.redstone
local sg = component.stargate
local zpm = component.zpmhub
local sides = require("sides")
local colors = require("colors")
local port = 1234
local asd = 1
local IDC = "1337"
local event = require("event")
local os = require("os")
local computer = require("computer")
local serialization = require("serialization")
local debug_card = component.debug
Bunker = "b1a0fd7e-47c3-43f9-a28a-c2215ac1f24f"
modem.open(123)

-- Mapping of color codes to their human-readable names
local color_names = {
    [colors.red] = "red",
    [colors.green] = "green",
    [colors.yellow] = "yellow",
    [colors.blue] = "blue"
}
local available_colors = {colors.red, colors.green, colors.yellow, colors.blue}

-- Game settings
local max_levels = 7 -- Total levels in the game
local sequence = {} -- The sequence of colors for the current game
local player_input = {} -- Tracks the player's input
local gamenumber = 0 -- Current level of the game
local is_game_over = false -- Game over flag
local dialoverride = false
manualdial = true

-- Function to generate a random color sequence
local function generate_sequence(levels)
    local available_colors = {colors.red, colors.green, colors.yellow, colors.blue}
    local sequence = {}

    if not levels or levels <= 0 then
        error("Invalid level count for sequence generation!")
    end

    for i = 1, levels do
        local color = available_colors[math.random(#available_colors)]
        if not color then
            error("Failed to pick a random color! Check available_colors.")
        end
        sequence[#sequence + 1] = color
    end

    -- Debug: Print the generated sequence
    print("Generated sequence:", serialization.serialize(sequence))
    return sequence
end

local function play_sequence(level)
    if not sequence or #sequence == 0 then
        error("Sequence is not initialized!")
    end
    print("Playing color sequence for level:", level)
    for i = 1, level do
        local color = sequence[i]
        if not color then
            error("Color at position " .. i .. " is nil!")
        end
        print("Activating color:", color_names[color] or ("unknown color code: " .. color))
        -- Turn on the current color
        reds.setBundledOutput(sides.south, color, 255)
        os.sleep(0.5)
        -- Turn off the current color
        reds.setBundledOutput(sides.south, color, 0)
        os.sleep(0.5)
    end
    print("Sequence complete!")
end

-- Function to reset the game
local function reset_game()
    print("Incorrect input! Resetting game...")
    gamenumber = 0
    sequence = generate_sequence(max_levels) -- Generate a new sequence for the new game
    is_game_over = true -- Indicate that the game should restart
end

local function startup_light_sequence()
    local startup_colors = {colors.green, colors.red, colors.yellow, colors.blue}
    for _, color in ipairs(startup_colors) do
        reds.setBundledOutput(sides.south, color, 255) -- Turn on the signal
        os.sleep(1) -- Wait for 1 second
        reds.setBundledOutput(sides.south, color, 0) -- Turn off the signal
        os.sleep(1)
    end
end

local function get_player_input(level)
    print("Waiting for player input...")
    player_input = {}

    -- Calculate the time limit
    local time_limit = 4 + (level - 1) * 2
    print("Time limit for this level:", time_limit, "seconds")

    local remaining_time = time_limit
    local post_input_wait = false -- Tracks whether to limit the wait time to 2 seconds

    while remaining_time > 0 do
        -- Check for button presses
        for _, color in ipairs(available_colors) do
            if reds.getBundledInput(sides.south, color) > 0 then
                -- Register player input
                player_input[#player_input + 1] = color
                print("Player pressed:", color_names[color] or "unknown")

                -- Debounce: Wait until the button is released
                while reds.getBundledInput(sides.south, color) > 0 do
                    os.sleep(0.1)
                end

                os.sleep(0.1) -- Small delay to prevent accidental double presses

                -- Validate the input immediately
                local current_index = #player_input
                if player_input[current_index] ~= sequence[current_index] then
                    print("Incorrect input! Expected:", sequence[current_index], "but got:", player_input[current_index])
                    return false -- Reset the game immediately
                end

                -- Handle completion of input
                if #player_input == level then
                    if level == max_levels then
                        print("Player completed the final level! Skipping timer wait.")
                        remaining_time = 0 -- Skip the timer for level 7
                    else
                        print("Player completed input. Waiting a maximum of 2 seconds...")
                        post_input_wait = true
                        remaining_time = math.min(remaining_time, 2) -- Limit remaining time to 2 seconds
                    end
                end
            end
        end

        -- Decrement the remaining time
        os.sleep(1) -- Wait for 1 second
        remaining_time = remaining_time - 1

        -- Debugging: Print remaining time
        if not post_input_wait or remaining_time <= 2 then
            print("DEBUG: Remaining time:", remaining_time, "seconds")
        end
    end

    -- Timeout: If the loop exits and no button was pressed
    if #player_input < level then
        print("Time's up! Player did not complete the sequence.")
        return false -- Player failed to complete the level
    end

    -- Debugging: Confirm player input collection
    print("Collected player input:", serialization.serialize(player_input))
    print("Expected sequence for level:", serialization.serialize({table.unpack(sequence, 1, level)}))

    -- Validate final input (redundant, but for safety)
    for i = 1, level do
        print("Comparing player_input[" .. i .. "]:", player_input[i], "with sequence[" .. i .. "]:", sequence[i])
        if player_input[i] ~= sequence[i] then
            print("Incorrect input! Expected:", sequence[i], "but got:", player_input[i])
            return false -- Player input is incorrect
        end
    end

    print("Player input is correct for level", level)
    return true -- Player input is correct
end

-- Function to flash green, yellow, blue, and red signals
local function flash_effect()
    local flash_colors = {colors.green, colors.yellow, colors.blue, colors.red}
    for i = 1, 5 do
        for _, color in ipairs(flash_colors) do
            reds.setBundledOutput(sides.south, color, 255) -- Turn on the signal
        end
        os.sleep(0.1) -- Short delay for flashing (adjust as needed)
        for _, color in ipairs(flash_colors) do
            reds.setBundledOutput(sides.south, color, 0) -- Turn off the signal
        end
        os.sleep(0.1) -- Short delay between flashes
    end
end

local function flash_failure_signal()
    print("Flashing cyan signal to indicate failure...")
    for i = 1, 3 do
        reds.setBundledOutput(sides.south, colors.cyan, 255) -- Turn on the cyan signal
        os.sleep(0.5) -- Wait 0.5 seconds
        reds.setBundledOutput(sides.south, colors.cyan, 0) -- Turn off the cyan signal
        os.sleep(0.5) -- Wait another 0.5 seconds
    end
end

local function game()
    print("Starting Simon Says...")
    sequence = generate_sequence(max_levels) -- Generate the full sequence for the game

    if not sequence or #sequence == 0 then
        error("Failed to generate a valid sequence! Check generate_sequence function.")
    end

    gamenumber = 0 -- Start from level 1

    while manualdial do
        if gamenumber == 0 or is_game_over then
            print("Game reset! Starting from level 1.")

            -- Play the startup light sequence at level 0
            print("Level 0: Playing startup light sequence...")
            startup_light_sequence()

            gamenumber = 0
            is_game_over = false
        end

        gamenumber = gamenumber + 1
        if gamenumber > max_levels then
            print("Congratulations! You completed Simon Says!")

            -- Flash green, yellow, blue, and red signals
            print("Flashing green, yellow, blue, and red signals...")
            flash_effect()

            -- Turn on the purple signal
            print("Activating purple signal...")
            reds.setBundledOutput(sides.south, colors.pink, 255) -- Adjust side if needed
            local result = table.pack(debug_card.runCommand("/scoreboard players add @a[x=15061,y=40,z=12626,dx=6,dy=3,dz=6] FinishedGame 1"))
            if result ~= nil then
                print(result[1], result[2])
            end

            break
        end

        print("Level:", gamenumber)
        play_sequence(gamenumber) -- Show the sequence to the player

        if not get_player_input(gamenumber) then
            print("Game reset triggered.")
            -- Flash cyan signal before resetting the game
            flash_failure_signal()
            reset_game() -- Reset the game if the player makes a mistake or time runs out
            os.sleep(1) -- Pause before restarting
        else
            print("Correct! Proceeding to level", gamenumber + 1)
        end
    end

    if not manualdial then
        reds.setBundledOutput(sides.south, colors.pink, 255)
    end
end
-- Function to handle incoming modem messages
local function handle_bunker_message()
    term.clear(true)
    print("Message received")
    dialoverride = true
end
charged = 0
redstoneyes = 0
simonsaysunlock = 0
simonsaysfinished = 0
address = {"Glyph 34","Glyph 12","Glyph 19","Glyph 33","Glyph 23","Glyph 28","Glyph 16","Glyph 17"}
OmegaAdress = {"Glyph 25","Glyph 10","Glyph 16","Glyph 29","Glyph 23","Glyph 19","Glyph 28","Glyph 17"}
print("Redstone Dialer")
print("--------------------------------------------------------------------------------------------------------------------------------------------------------------")
print()

repeat
    coroutine.yield()
    if reds.getBundledInput(sides.south, colors.white) > 0 and reds.getBundledInput(sides.south, colors.brown) > 0 and redstoneyes == 0 then
        print("Unlocked gate")
        redstoneyes = 1
    end

    -- Debug shutdown
    if reds.getBundledInput(sides.south, colors.gray) > 0 then
        asd = 2
    end

    -- Debug Dial
    if reds.getBundledInput(sides.south, colors.yellow) > 0 then
        debugdial = 1
    end

    -- Skip simon says game with computer
    if reds.getBundledInput(sides.south, colors.pink) > 0 then
        reds.setBundledOutput(sides.south, colors.pink, 255)
        manualdial = false
    end

    -- Omega Dial
    if reds.getBundledInput(sides.south, colors.black) > 0 then
        handle_bunker_message()
    end

    if simonsaysunlock == 1 and simonsaysfinished == 0 and reds.getBundledOutput(sides.south, colors.pink) < 1 then
        -- Run the simon says game
        game()
        simonsaysfinished = 1
    end

    if simonsaysunlock == 0 and charged == 0 and reds.getBundledOutput(sides.south, colors.purple) > 0 then
        -- Run the simon says game
        charged = 1
        simonsaysunlock = 1
    end

    if reds.getBundledOutput(sides.south, colors.pink) > 0 and simonsaysunlock == 1 then
        -- Skip the simon says game
        simonsaysfinished = 1
        reds.setBundledOutput(sides.south, colors.pink, 255)
    end

    if reds.getBundledInput(sides.south, colors.purple) > 0 and reds.getBundledOutput(sides.south, colors.purple) < 1 and charged == 0 then
    zpm.toggleSlots()
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    reds.setBundledOutput(sides.south, colors.purple, 0)
    os.sleep(0.7)
    zpm.toggleSlots()
    charged = 1
    reds.setBundledOutput(sides.south, colors.purple, 255)
    os.sleep(1)
    simonsaysunlock = 1
    computer.shutdown(true)
    end

    if redstoneyes == 1 or debugdial == 1 or dialoverride and component.stargate.getGateStatus() == "idle" then
            term.clear(true)
            print("Dialing Hidden gate")
            os.sleep(3)
            AddressBuffer = {"Glyph 34","Glyph 12","Glyph 19","Glyph 33","Glyph 23","Glyph 28","Glyph 16","Glyph 17"}
            if dialoverride then
                address = OmegaAdress
                AddressBuffer = OmegaAdress
            end
            for i,v in ipairs(address) do
                print(i,v)
            end
            function dialNext(dialed)
                glyph = address[dialed + 1]
                    local requirement = sg.getEnergyRequiredToDial(table.unpack(AddressBuffer)) -- Temp Workaround
                    if component.stargate.getGateStatus() == "incoming" then
                        term.clear(true)
                        print("ERROR: Incoming wormhole!")
                        redstoneyes = 0
                        debugdial = 0
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        os.sleep(1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        computer.shutdown(true)
                    elseif component.stargate.getEnergyRequiredToDial(address) == "address_malformed" then
                        term.clear(true)
                        print("ERROR: Destination Unavailable or does not exist!")
                        redstoneyes = 0
                        debugdial = 0
                        computer.shutdown(true)
                    elseif type(requirement) == "table" and requirement.canOpen == false then
                            local storedEnergy = sg.getEnergyStored()
                            local operatingTicks = (storedEnergy - requirement.open) / requirement.keepAlive
                            local operatingSeconds = math.floor(operatingTicks / 20)
                            reds.setBundledOutput(sides.south, colors.orange, 255)
                            os.sleep(1)
                            reds.setBundledOutput(sides.south, colors.orange, 0)
                            os.sleep(1)
                            reds.setBundledOutput(sides.south, colors.orange, 255)
                            os.sleep(1)
                            reds.setBundledOutput(sides.south, colors.orange, 0)
                            os.sleep(1)
                            reds.setBundledOutput(sides.south, colors.orange, 255)
                            os.sleep(1)
                            reds.setBundledOutput(sides.south, colors.orange, 0)
                            os.sleep(1)
                            reds.setBundledOutput(sides.south, colors.orange, 255)
                            os.sleep(1)
                            reds.setBundledOutput(sides.south, colors.orange, 0)
                            redstoneyes = 0
                            charged = 0
                            debugdial = 0
                            print("NOT ENOUGH POWER TO OPEN ... "..tostring(requirement.open).." RF NEEDED")
                            if dialoverride then
                            sendmessage = "NOT ENOUGH POWER TO OPEN "..tostring(requirement.open).." RF NEEDED"
                            modem.send(Bunker, 123, "error", sendmessage)
                            end
                            reds.setBundledOutput(sides.south, colors.purple, 0)
                            computer.shutdown(true)
                --      if requirement.canOpen == false then
                --          print("NOT ENOUGH POWER TO OPEN ... "..tostring(requirement.open).." RF NEEDED")
                    elseif simonsaysfinished == 1 or debugdial == 1 or dialoverride then
                            print("Engaging "..glyph.."... ")
                            sg.engageSymbol(glyph)
                    else
                        print("Not completed simon says!")
                        sg.engageGate()
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        component.computer.beep(150,1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        component.computer.beep(150,1)
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        component.computer.beep(150,1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        component.computer.beep(150,1)
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        component.computer.beep(150,1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        component.computer.beep(150,1)
                        reds.setBundledOutput(sides.south, colors.orange, 255)
                        component.computer.beep(150,1)
                        reds.setBundledOutput(sides.south, colors.orange, 0)
                        computer.shutdown(true)
                    end
            end
            eventID = event.listen("stargate_spin_chevron_engaged", function(evname, address, caller, num, lock, glyph)
                os.sleep(2)
                if lock then
                    term.clear(true)
                    print("Engaging...")
                    sg.engageGate()
                    if not dialoverride then
                        local result = table.pack(debug_card.runCommand("/scoreboard players add @a[x=15019,y=40,z=12603,dx=57,dy=13,dz=57] PuzzleGateActi 1"))
                        if result ~= nil then
                            print(result[1], result[2])
                        end
                        local result = table.pack(debug_card.runCommand("/effect @a[x=15019,y=40,z=12603,dx=57,dy=13,dz=57] moreplanets:infected_spore_protection 1800"))
                        if result ~= nil then
                            print(result[1], result[2])
                        end
                    elseif dialoverride then
                        local result = table.pack(debug_card.runCommand("/scoreboard players add @a[x=15019,y=40,z=12603,dx=57,dy=13,dz=57] openedpargate 1"))
                        if result ~= nil then
                            print(result[1], result[2])
                        end
                    end
                    doing = false
                    eventID = event.listen("stargate_wormhole_stabilized", function(evname, address, caller, isInitiating)
                    if isInitiating then
                        if dialoverride then
                            print("sending code to omega: ", IDC)
                            modem.broadcast(1234, "code", IDC)
                            reds.setBundledOutput(sides.south, colors.black, 255)
                        else
                            print("sending code: ", IDC)
                            sg.sendIrisCode(IDC)
                            reds.setBundledOutput(sides.south, colors.black, 255)
                        end
                    else
                    end
                    end)
                    zpm.toggleSlots()
                    print("30 seconds before wormhole closes")
                    os.sleep(9)
                    zpm.toggleSlots()
                    os.sleep(11)
                    print("10 seconds")
                    os.sleep(5)
                    os.sleep(1) print("5")
                    os.sleep(1) print("4")
                    os.sleep(1) print("3")
                    os.sleep(1) print("2")
                    os.sleep(1) print("1")
                    reds.setBundledOutput(sides.south, colors.purple, 0)
                    reds.setBundledOutput(sides.south, colors.pink, 0)
                    reds.setBundledOutput(sides.south, colors.black, 0)
                    sg.disengageGate()
                    os.sleep(1) print("Stargate Shutdown")
                    redstoneyes = 0
                    charged = 0
                    simonsaysunlock = 0
                    simonsaysfinished = 0
                    debugdial = 0
                    address = {"Glyph 34","Glyph 12","Glyph 19","Glyph 33","Glyph 23","Glyph 28","Glyph 16","Glyph 17"}
                    AddressBuffer = {"Glyph 34","Glyph 12","Glyph 19","Glyph 33","Glyph 23","Glyph 28","Glyph 16","Glyph 17"}
                    dialoverride = false
                    manualdial = true
                    else
                        dialNext(num)
                    end
                end)

            dialNext(0)
            doing = true
            print()
            while doing do os.sleep(0.1) end
    end

until asd == 2