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

-- 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

-- 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 true 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
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"}
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

	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
	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(5)
	simonsaysunlock = 1
	computer.shutdown(true)
	end

	if redstoneyes == 1 or debugdial == 1 and component.stargate.getGateStatus() == "idle" then
			term.clear(true)
			print("Dialing Hidden gate")
			os.sleep(3)
			for i,v in ipairs(address) do
				print(i,v)
			end

			function dialNext(dialed)
			AddressBuffer = {"Glyph 34","Glyph 12","Glyph 19","Glyph 33","Glyph 23","Glyph 28","Glyph 16","Glyph 17"}
				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")
							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 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()
					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
					doing = false
					eventID = event.listen("stargate_wormhole_stabilized", function(evname, address, caller, isInitiating)
					if isInitiating then
						print("sending code: ", IDC)
						sg.sendIrisCode(IDC)
						reds.setBundledOutput(sides.south, colors.black, 255)
					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
					else
						dialNext(num)
					end
				end)

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

until asd == 2