S2 & S3&K Speedometer

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
------ Sonic Speedometer v1.0 --------------------------------------------------
------ For multiple versions ---------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

-- This script shows several interesting values read directly out of the game
-- engine.  All of these, except for the speedometer, will autohide themselves.
-- This currently works for Sonic 2 and Sonic 3&K.
-- Use Gens Rerecording http://code.google.com/p/gens-rerecording/
-- Items marked with a + will appear when you press Up + C; tap C multiple times
-- to get them to stay onscreen longer.  Or, use Up + B to toggle them.
--  + Checkpoint: Shows most recent checkpoint.
--  + Remaining: Shows how many rings are left to collect until you get a
--    Perfect Bonus.
--  + Circular thing with a number: This shows you the distance and bearing to
--    the nearest ring.  In other words, the needle in the circle shows you in
--    what direction the nearest ring lies, and the number next to it shows how
--    far away the ring is.
--    Yes, I know this won't always give a correct distance/bearing for
--    Metropolis Zone due to the wrapping.
--  + UP D/L/R: These change color to show which collision collision plane is
--    active: yellow for the primary, cyan for the secondary.
--  - LOCK: Shows up when a control lock engages.
--  - Air: Shows up under water.  Shows how how many seconds of air are left.
--  - Invincible: This timer shows up when you get an invincibility monitor.
--  - Speed Shoe: When this timer show up, it shows what you'd think it shows.
--  - Unlabeled red number: Shows how many FRAMES of temporary invunerability
--    you have left.
--  - Flying: Shows up when Tails is flying
--  - Continues: Reminds you how many continues you have got.
--  - Speed: This shows your speed.  The dial also features a digital readout
--    of your speed below.  The gray needle bounces up and down to show your
--    most recent maximum speed; the red number above shows what this speed is.
--    You can change the range of the speedometer
--  - Boost: Shows up only when you do a spin dash.  Freezes to show how
--    powerful the dash was.
--
-- Lua is supposed to be easy to understand, even for non-coders.  You shouldn't
-- have trouble changing what gets shown on screen.
--
-- To Do:
--  - Fix ring finder for Metropolis Zone and other zones that loop
--  - Implement non-sucky arc-drawing and fill algorithms.  I'll probably never
--    actually do this, but feel free to contribute one for me.
--
-- Consider this script to be given out under the GPL. --- DrDnar, 1 May 2012
--
-- Change log:



--------------------------------------------------------------------------------
------ Game-specific Data ------------------------------------------------------
--------------------------------------------------------------------------------

isPaused = {}
gameActive = {}
buttonsChanged = {}
perfectCounter = {}
xLocation = {}
yLocation = {}
xSpeed = {}
ySpeed = {}
continues = {}
checkpoint = {}
airRemaining = {}
hLockTimer = {}
invulnTimer = {}
invincTimer = {}
speedShoeTimer = {}
spinDashFlag = {}
spinDashCharge = {}
collisionsUpFlag = {}
collisionsDLRFlag = {}
ringTable = {}
checkpoint = {}
spriteTable = {}
currentCharacter = {}

function ReadROM(start, length)
    array = {}
    for n = 0, length-1 do
        array[n+1] = memory.readbyte(start + n)
    end
    return array
end

function ArrayEquals(one, two)
    local n = 1
    while one[n] ~= nil and two[n] ~= nil do
--      print(string.format("%2X %2X | ", one[n], two[n]))
        if one[n] ~= two[n] then return false end
        n = n + 1
    end
    if one[n] ~= two[n] then return false end
    return true
end

romIDLocation = 0x180
romIDLength = 14
s1id = {0x47, 0x4D, 0x20, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x34, 0x39, 0x2D, 0x30, 0x31}
--        G     M           0     0     0     0     4     0     4     9     -     0     1
sonic1 = 1

s2id = {0x47, 0x4D, 0x20, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x35, 0x31, 0x2D, 0x30, 0x31}
--        G     M           0     0     0     0     1     0     5     1     -     0     1
sonic2 = 2

s3kid = {0x47, 0x4D, 0x20, 0x4D, 0x4B, 0x2D, 0x31, 0x35, 0x36, 0x33, 0x20, 0x2D, 0x30, 0x30}
--         G     M           M     K     -     1     5     6     3           -     0     0
sonic3k = 3

--if ArrayEquals(s1id, ReadROM(romIDLocation, romIDLength)) then
--  isS1 = true
--  currentGame = sonic1
--end

if ArrayEquals(s2id, ReadROM(romIDLocation, romIDLength)) then
    print("ROM type: S2")
    isS2 = true
    currentGame = sonic2
    isPaused.location = 0xFFF63B
    gameActive.location = 0xFFF711
    buttonsChanged.location = 0xFFF605
    perfectCounter.location = 0xFFFF40
    xLocation.location = 0xFFB008
    yLocation.location = 0xFFB00C
    xSpeed.location = 0xFFB010
    ySpeed.location = 0xFFB012
    continues.location = 0xFFFE18
    checkpoint.location = 0xFFFE30
    airRemaining.location = 0xFFB028
    hLockTimer.location = 0xFFB02E
    function invulnTimer.get() return memory.readwordunsigned(0xFFB030) end
    function invincTimer.get() return memory.readwordunsigned(0xFFB032) end
    function speedShoeTimer.get() return memory.readwordunsigned(0xFFB034) end
    spinDashFlag.location = 0xFFB039
    spinDashFlag.exists = true
    spinDashCharge.location = 0xFFB03A
    collisionsUpFlag.location = 0xFFB03E
    collisionsUpFlag.exists = true
    collisionsDLRFlag.location = 0xFFB03F
    ringTable.location = 0xFFE806
    ringTable.length = 0x600
    ringTable.type = sonic2
    checkpoint.location = 0xFFFE30
    spriteTable.itemSize = 0x40
    spriteTable.location = 0xFFB000
end

if ArrayEquals(s3kid, ReadROM(romIDLocation, romIDLength)) then
    print("ROM type: S3&K")
    isS3K = true
    currentGame = sonic3k
    isPaused.location = 0xFFF63B
    gameActive.location = 0xFFF711
    buttonsChanged.location = 0xFFF605
    perfectCounter.location = 0xFFFF04
    xLocation.location = 0xFFB010
    yLocation.location = 0xFFB014
    xSpeed.location = 0xFFB018
    ySpeed.location = 0xFFB01A
    continues.location = 0xFFFE18
    checkpoint.location = 0xFFFE2A
    airRemaining.location = 0xFFB02C
    hLockTimer.location = 0xFFB032
    function invulnTimer.get() return memory.readbyteunsigned(0xFFB034) end
    function invincTimer.get() return memory.readbyteunsigned(0xFFB035)*8 end
    function speedShoeTimer.get() return memory.readbyteunsigned(0xFFB036)*8 end
    spinDashFlag.location = 0xFFB03D
    spinDashFlag.exists = true
    spinDashCharge.location = 0xFFB03E
    collisionsUpFlag.location = 0xFFB046
    collisionsDLRFlag.location = 0xFFB047
    ringTable.location = 0xFFE806
    ringTable.length = 0x600
    ringTable.type = sonic3k
    checkpoint.location = 0xFFFE30
    spriteTable.itemSize = 0x4A
    spriteTable.location = 0xFFB000
    currentCharacter.location = 0xFFFF08
end

if currentGame == nil then
    error("Possibily unsupported game. Script editing is required.")
end



--------------------------------------------------------------------------------
------ Meter Object ------------------------------------------------------------
--------------------------------------------------------------------------------
-- This object lets you draw a generic meter or dial, with multiple needles.
-- To declare a meter, do
--  - Meter:Create(baseX, baseY, size, thetaMin, thetaMax, scaleInc, fgColor, bgColor, fill)
--    - baseX, baseY: X&Y location for the meter
--    - size: Radius of the meter
--    - thetaMin, thetaMax: These variables control the arc that the meter's
--      range will sweep.  You could, for example, have the meter sweep a range
--      less than the semicircle used in this example.
--    - scaleInc: If not nil, this controls how often tic marks appear on the
--      meter's scale.  Specified as an angular incrememt.
--    - fgColor, bgColor: Controls the color of the main outer arc and the
--      shadowing of that arc.
--    - fill: Controls the fill color of the arc.
--    * The color values tend to look funny if you specify an opacity that isn't
--      fully opaque or transparent.
-- This function will return a new Meter object.  Don't forget to assign it to a
-- variable:
--  - aMeter = Meter:Create(...)
-- To draw the meter on the screen, first do
--  - aMeter:DrawMeter()
-- to draw the meter's basic graphic.  Then, for each needle value you want to
-- show, do
--  - aMeter:DrawNeedle(percentage, color, saturate, size)
--    - percentage: A number between 0 and 1 that represents the fraction of the
--      arc between thetaMin and thetaMax that the needle should point to.
--    - color: The color of the needle line.  At the moment, there is no support
--      for shadowing the needle color.
--    - saturate: If true, then any percentage value less than 0 will be treated
--      as zero, and any value greater than 1 will be treated as one.
--    - size: Controls the length (radius) of the needle.
-- The parameters after color may be omitted.  They will default to
--    - color: fgColor passed to Create() method
--    - saturate: false
--    - size: size passed to Create() method.

Meter = {}
Meter.__index = Meter

function Meter:Create(baseX, baseY, size, thetaMin, thetaMax, scaleInc, fgColor, bgColor, fill)
    local newItem = {}
    setmetatable(newItem, Meter)  -- Bind object methods to new object
    newItem.baseX = baseX -- x location
    newItem.baseY = baseY -- y location
    newItem.thetaMin = thetaMin
    newItem.thetaMax = thetaMax
    newItem.thetaDelta = thetaMax - thetaMin
    newItem.size = size -- size
    newItem.scaleInc = scaleInc
    newItem.bg = bgColor
    newItem.fg = fgColor
    newItem.fill = fill
    return newItem
end

function Meter:DrawMeter()
    local inc = math.asin(1/self.size)/(self.size/2)
    local start, stop = self.thetaMin, self.thetaMax
    if start > stop then
        start, stop = stop, start
    end
    local theta = start
    local size, basex, basey = self.size, self.baseX, self.baseY
    local cos, sin

    while theta < stop do
        cos = math.cos(theta)
        sin = math.sin(theta)
        gui.pixel(sin*size + basex, cos*size + basey, self.fg)
        gui.pixel(sin*(size+0.5) + basex, cos*(size+0.5) + basey, self.fg)
        --gui.pixel(sin*(size-1) + basex, cos*(size-1) + basey, self.fg)
        if self.bg ~= nil then
            gui.pixel(sin*(size-1) + basex, cos*(size-1) + basey, self.bg)
            gui.pixel(sin*(size-1.5) + basex, cos*(size-1.5) + basey, self.bg)
        end
        if self.bg ~= nil then
            gui.line(basex, basey, sin*(size-2) + basex, cos*(size-2) + basey, self.fill)
        end
        theta = theta + inc
    end
    theta = start
    while theta < stop do
        cos = math.cos(theta)
        sin = math.sin(theta)
        if self.scaleInc ~= nil and ((theta-start)/self.scaleInc)%1 * self.scaleInc > (self.scaleInc-(2*inc)) then
            gui.pixel(sin*(size-1) + basex, cos*(size-1) + basey, self.fg)
            gui.pixel(sin*(size-1.5) + basex, cos*(size-1.5) + basey, self.fg)
            gui.pixel(sin*(size-2) + basex, cos*(size-2) + basey, self.fg)
            gui.pixel(sin*(size-2.5) + basex, cos*(size-2.5) + basey, self.fg)
--          gui.line(sin*(size-1) + basex, cos*(size-1) + basey, sin*(size-3) + basex, cos*(size-3) + basey, self.fg)
        end
        theta = theta + inc
    end

end

function Meter:DrawNeedle(percent, fgColor, saturate, size)
    if saturate and percent > 1 then
        percent = 1
    end
    if saturate and percent < 0 then
        percent = 0
    end
    if fgColor == nil then
        fgColor = self.fgColor
    end
    if size == nil then
        size = self.size - 3
    end
    local theta = percent * self.thetaDelta + self.thetaMin
    local sin, cos = math.cos(theta), math.sin(theta)

    gui.line(self.baseX, self.baseY, size*cos + self.baseX, size*sin + self.baseY, fgColor)
end



--------------------------------------------------------------------------------
------ Globals -----------------------------------------------------------------
--------------------------------------------------------------------------------

lastSpindashValue = 0
boostMeter = Meter:Create(231, 214, 20, 3*math.pi/2, math.pi/2, math.pi/8, 0xFFFF00FF, 0x000000FF, 0x202020FF)
boostTimer = 0
speedometer = Meter:Create(287, 214, 20, 3*math.pi/2, math.pi/2, math.pi/8, 0xFFFF00FF, 0x000000FF, 0x202020FF)
maxSpeed = 0
maxMaxSpeed = 0
maximumSpeed = 4096
ringFinder = Meter:Create(27, 72, 10, math.pi*2+math.pi/2, math.pi/2, math.pi/4, 0xFFFF00FF, 0x000000FF, 0x202020FF)
lastRingBearing = 0
showThingsTimer = 0
showThingsFlag = false
fps = 60 -- frames per second, change if needed

nearestDistance = 0 -- needs init, not really global though


--------------------------------------------------------------------------------
------ Show Stuff on-Screen ----------------------------------------------------
--------------------------------------------------------------------------------

gui.register( function ()
-- Hide the additional HUD elements if we're not in the normal game loop.
if memory.readbyte(gameActive.location) ~= 0 then


    perfectCounter.value = memory.readwordunsigned(perfectCounter.location)
    -- Cache Sonic's location and other things
    xLocation.value = memory.readwordunsigned(xLocation.location)
    yLocation.value = memory.readwordunsigned(yLocation.location)
    xSpeed.value = memory.readwordsigned(xSpeed.location)
    ySpeed.value = memory.readwordsigned(ySpeed.location)
    perfectCounter.value = memory.readwordunsigned(perfectCounter.location)
    if currentGame == sonic3k then
        currentCharacter.value = memory.readwordunsigned(currentCharacter.location)
    end


-- Autohide various things

    isPaused.value = memory.readbyte(isPaused.location) ~= 0
    currentButtons = joypad.get(1)
    if currentButtons.up and AND(memory.readbyte(buttonsChanged.location), 0x20) == 0x20 then
        showThingsTimer = showThingsTimer + 120
        showThingsFlag = false
    else
        if not isPaused.value and showThingsTimer ~= 0 then
            showThingsTimer = showThingsTimer - 1
        end
    end
    if currentButtons.up and AND(memory.readbyte(buttonsChanged.location), 0x10) == 0x10 then
        if showThingsFlag then
            showThingsFlag = false
        else
            showThingsFlag = true
            showThingsTimer = 1
        end
    end
    if showThingsFlag then
        showThingsTimer = 1
    end
    if showThingsTimer == 0 then
        showThingsFlag = false
    end


-- Ring finder

    haveBearing = false
    -- Sonic 2
    if perfectCounter.value ~= 0 and not isPaused.value and currentGame == sonic2 then
        -- Initalize scanning loop
        keepGoing = true
        address = 0xFFE806
        nearestDistance = 65535
        nearestBearing = 0

        -- Scan the ring table in RAM, keeping track of the smallest distance found.
        -- The ring table has 6-byte entries.  The first word is the
        -- destruction animation counter.  The next two are simply the x and y
        -- location.  0xFFFFFFFF marks the end of the table.
        while keepGoing and address < 0xFFEDFF do
            value = memory.readwordunsigned(address)
            if value == 0 then
                deltax = memory.readwordunsigned(address+2) - xLocation.value
                deltay = memory.readwordunsigned(address+4) - yLocation.value
                value = math.sqrt(deltax*deltax + deltay*deltay)
                if value < nearestDistance then
                    nearestDistance = value
                    nearestBearing = math.atan2(deltay, deltax)
                end
                haveBearing = true
            else
                if value == 0xFFFF and memory.readwordunsigned(address+2) == 0xFFFF then
                    keepGoing = false
                end
            end
            address = address + 6
        end
    end
    -- S3&K
    if perfectCounter.value ~= 0 and (currentGame == sonic3k) then
        haveBearing = true
        -- Scan backwards
        keepGoing = true
        address = memory.readwordunsigned(0xFFEE42)
        address = address * 65536 + memory.readwordunsigned(0xFFEE44)
        status = 0xFF0000 + memory.readwordunsigned(0xFFEE4A)
        nearestDistance = 65535
        nearestBearing = 0
        while keepGoing do
            value = memory.readwordunsigned(address)
            if value ~= 0 then
                value = memory.readwordunsigned(status)
                if memory.readwordunsigned(status) == 0 then
                    deltax = memory.readwordunsigned(address) - xLocation.value
                    deltay = memory.readwordunsigned(address+2) - yLocation.value
                    value = math.sqrt(deltax*deltax + deltay*deltay)
                    if value < nearestDistance then
                        nearestDistance = value
                        nearestBearing = math.atan2(deltay, deltax)
                        haveBearing = true
                    end
                end
            else
                keepGoing = false
            end
            address = address - 4
            status = status - 2
        end
        -- Scan forwards
        keepGoing = true
        address = memory.readwordunsigned(0xFFEE42)
        address = address * 65536 + memory.readwordunsigned(0xFFEE44)
        status = 0xFF0000 + memory.readwordunsigned(0xFFEE4A)
        while keepGoing do
            value = memory.readwordunsigned(address)
            if value ~= 0xFFFF then
                if memory.readwordunsigned(status) == 0 then
                    deltax = memory.readwordunsigned(address) - xLocation.value
                    deltay = memory.readwordunsigned(address+2) - yLocation.value
                    value = math.sqrt(deltax*deltax + deltay*deltay)
                    if value < nearestDistance then
                        nearestDistance = value
                        nearestBearing = math.atan2(deltay, deltax)
                        haveBearing = true
                    end
                end
            else
                keepGoing = false
            end
            address = address + 4
            status = status + 2
        end
    end
    if haveBearing then
        if not isPaused.value then
            -- Make 0 < nearestBearing < 2*pi
            if nearestBearing < 0 then nearestBearing = nearestBearing + 2*math.pi end
            -- Now remap that to be between 0 and 1 (input for the DrawNeedle() method)
            nearestBearing = nearestBearing/(2*math.pi)
            -- Here's where we get to the fancy animation.  This finds the
            -- direction the needle needs to swing in to make the shortest arc to
            -- the current bearing.
            smallestDelta = 1
            for n = -1, 1 do
                delta = math.abs(nearestBearing - lastRingBearing - n)
                if smallestDelta > delta then
                    smallestDelta = delta
                    value = nearestBearing - lastRingBearing - n
                end
            end
            -- Then, by dividing by a number, we make it swing to the location,
            -- instead of jumping there instantly.
            if math.abs(value) > 0.006 then -- Implement minimum speed
                value = (value/math.abs(value)) * (value*value / 3 + 0.002)
                if math.abs(value) > 0.03 then -- Implement maximum speed
                    value = 0.03 * value/math.abs(value)
                end
            end
            lastRingBearing = value + lastRingBearing
            lastRingBearing = lastRingBearing - math.floor(lastRingBearing)
            nearestDistance = nearestDistance - 14
            if nearestDistance < 0 then nearestDistance = 0 end
        end

        -- Now show the results, if wanted.  Note that the needle still
        -- swings when it isn't visible.
        if showThingsTimer ~= 0 then
            ringFinder:DrawMeter()
            ringFinder:DrawNeedle(lastRingBearing, 0xFFFF00FF)
            gui.text(40, 64, string.format("%d", nearestDistance), 0xFFFF00FF, 0x000000FF)
        end
    end


-- Speed

    value = math.sqrt(xSpeed.value*xSpeed.value + ySpeed.value*ySpeed.value)

    speedometer:DrawMeter()
    if value > maxSpeed then
        maxSpeed = value
        maxMaxSpeed = value
    else
        if not isPaused.value then
            maxSpeed = maxSpeed - 16
            if maxSpeed < 0 then
                maxSpeed = 0
                maxMaxSpeed = 0
            end
        end
    end
    if maxMaxSpeed ~= 0 then
        gui.text(290, 184, string.format("%5d", maxMaxSpeed), 0xFF0000FF, "black")
    end
    gui.text(266, 216, string.format("Speed:%5d", value), 0xFFFF00FF, "black")
    speedometer:DrawNeedle(maxSpeed/maximumSpeed, 0xFF0000FF, false, speedometer.size-4)
    speedometer:DrawNeedle(value/maximumSpeed, 0xFFFF00FF)


-- Perfect counter

    if perfectCounter then
    if showThingsTimer ~= 0 then
    color = 0xFFFF00FF
    bgColor = 0x000000FF
    value = perfectCounter.value
    if value == 0 then
        color = 0xFFFFFF60
        bgColor = 0x00000060
    end
    gui.text(17, 54, string.format("Remaining: %3d", value), color, bgColor)
    end
    end


-- Spin-dash "Boost meter"

    if spinDashFlag then
    color = 0xFFFF00FF--0xFFFF00A0
    bgColor = 0x000000FF--0x000000A0
    boostColor = 0x808080FF
    if memory.readbyte(spinDashFlag.location) ~= 0 then
        lastSpindashValue = memory.readword(spinDashCharge.location)
        boostColor = 0xFF2020FF
        boostTimer = 90
    else
        if not isPaused.value then
            if boostTimer > 0 then boostTimer = boostTimer - 1 end
        end
    end
    if boostTimer > 0 then
        boostMeter:DrawMeter()
        boostMeter:DrawNeedle(lastSpindashValue/0x800, boostColor)
        message = string.format("Boost: %4d", lastSpindashValue)
        gui.text(210, 216, message, color, bgColor)
    end
    end


-- Collisions selection

    if showThingsTimer ~= 0 then
    color = 0xFFFF00FF
    bgColor = 0x000000FF
    if memory.readbyte(collisionsUpFlag.location) ~= 0x0C then
        color = 0x00FFFFFF
    end
    gui.text(276, 0, "UP", color, bgColor)
    color = 0xFFFF00FF
    bgColor = 0x000000FF
    if memory.readbyte(collisionsDLRFlag.location) ~= 0x0D then
        color = 0x00FFFFFF
    end
    gui.text(290, 0, "D/L/R", color, bgColor)
    end


-- Horizontal control lock

    value = memory.readwordunsigned(hLockTimer.location)
    if value ~= 0 then
        gui.text(300, 18, "LOCK", 0xFF0000FF, 0x000000FF)
    end


-- Continues

    if showThingsTimer ~= 0 then
    color = 0xFFFF0080
    bgColor = 0x00000080
    gui.text(17, 216, string.format("Continues: %d", memory.readbyte(continues.location)), color, bgColor)
    end


-- Checkpoint

    if showThingsTimer ~= 0 then
    color = 0xFFFFFF80
    bgColor = 0x00000080
    value = memory.readbyteunsigned(checkpoint.location)
    if value ~= 0 then
        color = 0xFFFF00FF
        bgColor = 0x000000FF
    end
    gui.text(17, 0, string.format("Checkpoint: %d", value), color, bgColor)
--  memory.writebyte(0xFFFE30,0)--Disables checkpoints
    end


-- Timers

    -- Air
    value = memory.readbyte(airRemaining.location)
    if value ~= 0x1E then
        gui.text(80, 0, string.format("Air: %2d", value), 0xFFFFFFFF, 0x000000FF)
    end

    -- Temporary invunerability
    value = invulnTimer.get()
    if value ~= 0 then
        gui.text(246, 9, string.format("%4d", value), 0xFF0000FF, 0x000000FF)
    end

    -- Invincibility
    value = invincTimer.get()
    if value ~= 0 then
        gui.text(120, 0, string.format("Invincible: %2d", value/fps), 0xFFFFFFFF, 0x000000FF)
    end

    -- Speed shoe
    value = speedShoeTimer.get()
    if value ~= 0 then
        gui.text(192, 0, string.format("Speed Shoe: %2d", value/fps), 0xFFFFFFFF, 0x000000FF)
    end

    -- Tails flying time
    if currentGame == sonic3k then
        if currentCharacter.value == 0 then
            value = memory.readbyteunsigned(0xFFB06F)*2
            if memory.readbyteunsigned(0xFFB079) ~= 0 then
                gui.text(192, 9, string.format("Flying: %2d", value/fps), 0xFFFFFFFF, 0x000000FF)
            end
        end
        if currentCharacter.value == 02 then
            value = memory.readbyteunsigned(0xFFB025)*2
            if memory.readbyteunsigned(0xFFB02F) ~= 0 then
                gui.text(192, 9, string.format("Flying: %2d", value/fps), 0xFFFFFFFF, 0x000000FF)
            end
        end
    end

else
    showThingsFlag = false
end
end)