UI

-- Client script
-- UI Container
--  Panel
--   Slider Panel
--    Script
--    Handle
--    Progress Bar
local ROOT = script.parent

-- The handle that will be dragged left and right to change the slider amount.
local HANDLE = script:GetCustomProperty("Handle"):WaitForObject()

-- The UI progress bar that will be updated.
local PROGRESS_BAR = script:GetCustomProperty("ProgressBar"):WaitForObject()

-- With of the root container
local WIDTH = ROOT.width

local localPlayer = Game.GetLocalPlayer()
local movingHandle = false
local startingPercent = PROGRESS_BAR.progress
local sliderAmount = WIDTH * startingPercent
local currentAbsPos = nil

-- Set the starting position of the handle.
HANDLE.x = sliderAmount

-- Set the movingHandle boolen to false on release of a binding.
local function OnActionReleased(player, action)
    if action == "Shoot" then
        movingHandle = false
    end
end

-- Set the movingHandle boolen to true on pressing of a binding.
local function OnActionPressed(player, action)
    if action == "Shoot" then
        movingHandle = true
    end
end

function Tick()
    if movingHandle then

        -- GetAbsolutePosition may not return the correct vector values until
        -- the UI object has fully initalized. So in this case the script will
        -- set the currentAbsPos if it is nil, as it is needed in the calculation.
        if not currentAbsPos then
            currentAbsPos = HANDLE:GetAbsolutePosition()
        end

        local mousePos = Input.GetCursorPosition()
        local pos = HANDLE:GetAbsolutePosition()

        -- Workout the min and max coordinates the slider is allowed to move by.
        local min = currentAbsPos.x - WIDTH * startingPercent
        local max = currentAbsPos.x + WIDTH - (WIDTH * startingPercent)
        local x = mousePos.x

        -- Make sure the slider can not be moved outside the bounds for left and right.
        x = math.max(x, min)
        x = math.min(x, max)

        -- Set the new absolute position for the x, but leave y intact.
        HANDLE:SetAbsolutePosition(Vector2.New(x, pos.y))

        -- Updated the progress bar.
        PROGRESS_BAR.progress = HANDLE.x / WIDTH
    end
end

Input.actionPressedEvent:Connect(OnActionPressed)
Input.actionReleasedEvent:Connect(OnActionReleased)

local lastModalType = nil

function Tick()
    local newType = UI.GetCoreModalType()
    if lastModalType ~= newType then
        lastModalType = newType
        if newType then
            print("New modal active: "..ModalTypeToString(newType))
        else
            print("Modal closed.")
        end
    end
end

function ModalTypeToString(modalType)
    if modalType == CoreModalType.PAUSE_MENU then return "Pause Menu" end
    if modalType == CoreModalType.CHARACTER_PICKER then return "Character Picker" end
    if modalType == CoreModalType.MOUNT_PICKER then return "Mount Picker" end
    if modalType == CoreModalType.EMOTE_PICKER then return "Emote Picker" end
    if modalType == CoreModalType.SOCIAL_MENU then return "Social Menu" end
    return "Unknown Modal" -- Future-proof fallback
end

local LOCAL_PLAYER = Game.GetLocalPlayer()

local viewForward = nil
local smallestDistSqr = nil
local targetPlayer = nil
local targetProjection = nil

UI.SetCursorVisible(true)

function Tick()
    Reset()
    for _,player in ipairs(Game.GetPlayers()) do
        if player ~= LOCAL_PLAYER then
            TestPlayer(player)
        end
    end
    DrawDebug()
end

function Reset()
    local viewRot = LOCAL_PLAYER:GetViewWorldRotation()
    viewForward = Quaternion.New(viewRot):GetForwardVector()

    targetPlayer = nil
end

function TestPlayer(player)
    local point = player:GetWorldPosition()

    local projection = UI.GetCursorPlaneIntersection(point, viewForward)
    if not projection then return end

    local distSqr = (point - projection).sizeSquared

    if targetPlayer == nil
    or distSqr < smallestDistSqr then
        smallestDistSqr = distSqr
        targetPlayer = player
        targetProjection = projection
    end
end

function DrawDebug()
    if targetPlayer then
        local playerPos = targetPlayer:GetWorldPosition()
        local params = {thickness = 3, color = Color.RED}
        CoreDebug.DrawSphere(playerPos, 50, params)
        CoreDebug.DrawLine(playerPos, targetProjection, params)
    end
end

UI.SetCursorLockedToViewport(true)
UI.SetCursorVisible(true)

function OnActionPressed(player, action)
    if action == "Shoot" then
        local cursorPos = Input.GetCursorPosition()
        local hit = UI.GetHitResult(cursorPos)
        if hit and hit.other then
            print("Clicked on: "..hit.other.name)
        else
            print("Nothing was clicked on.")
        end
        UI.SetCursorVisible(false)
        Task.Wait(0.2)
        UI.SetCursorVisible(true)
    end
end

Input.actionPressedEvent:Connect(OnActionPressed)

-- Rectangular bounds of the screen's safe area
local rectangle = UI.GetSafeArea()
print(tostring(rectangle))

-- Total screen size
local screenSize = UI.GetScreenSize()
print(tostring(screenSize))

-- Compare the two to figure out if there are "unsafe" areas
local notchWidth = nil
if rectangle.left > 0 then
    notchWidth = rectangle.left
    print("Notch area of " .. notchWidth .. " on LEFT side.")
end
if rectangle.right < screenSize.x then
    notchWidth = screenSize.x - rectangle.right
    print("Notch area of " .. notchWidth .. " on RIGHT side.")
end
if not notchWidth then
    print("The whole screen is safe!")
end

-- Grab the text object
local propUIText = script:GetCustomProperty("UIText"):WaitForObject()

-- Represents how many seconds are left until the UI Text moves to the next player
local timeLeft = 0

-- Determines how long (in seconds) the text hovers above the name of a player
local intervalTime = 2

-- Represents which player the UI Text will is currently hovering over
local playerIndex = 1

-- Stores a list of players in the game
local playerList = Game.GetPlayers()

-- Stores the player object that the UI Text should hover above
local targetPlayer = nil

function Tick(deltaTime)
    -- Update the "playerList" to reflect any changes to the list of players in the game (players leaving the game or entering the game)
    playerList = Game.GetPlayers()

    -- Update the "timeLeft" variable
    timeLeft = timeLeft - deltaTime

    -- If "timeLeft" has reached 0 and there are still players in the game, reset the "timeLeft" variable and move the text to the next player
    if(timeLeft <= 0 and #playerList > 0) then
        -- Reset the "timeLeft" variable to "intervalTime" number of seconds
        timeLeft = intervalTime

        -- Move the "playerIndex" to the next player in the "playerLIst"
        playerIndex = playerIndex + 1

        -- If "playerIndex" is larger than the length of "playerList", reset "playerIndex" to the beginning of "playerList"
        if(playerIndex > #playerList) then
            playerIndex = 1
        end

        -- Update the "targetPlayer" variable with the player object located at "playerIndex" position on the "playerList"
        targetPlayer = playerList[playerIndex]
    end

    -- If "targetPlayer" refers to an actual player, update the position of the UI Text to
    -- be above that player's head
    if(Object.IsValid(targetPlayer)) then
        -- Get the position of the player's head by vertically offsetting the position of the player
        local playerHeadPos = targetPlayer:GetWorldPosition() + Vector3.New(0, 0, 120)

        -- Convert the position of the player's head to 2D coordinates
        local playerHeadScreenPos = UI.GetScreenPosition(playerHeadPos)

        -- Change the text of the UI Text to display the name of the "targetPlayer"
        propUIText.text = targetPlayer.name

        -- Move the UI Text to the "playerHeadScreenPos" position
        propUIText.x = playerHeadScreenPos.x
        propUIText.y = playerHeadScreenPos.y
    end
end

local screenSize = UI.GetScreenSize()
local width = CoreMath.Round(screenSize.x)
local height = CoreMath.Round(screenSize.y)
print("The player's screen size is: "..width.."x"..height)

Task.Wait(1)
if UI.IsCursorLockedToViewport() then
    UI.PrintToScreen("Core begins with the cursor locked")
else
    UI.PrintToScreen("In Core, the cursor does not begin locked")
end

local API = {}
_G.CursorUtils = API

local usageCount = 0

function API.ShowCursor()
    if UI.CanCursorInteractWithUI()
    or UI.IsCursorVisible() then
        usageCount = usageCount + 1
    else
        usageCount = 1
    end
    UI.SetCanCursorInteractWithUI(true)
    UI.SetCursorVisible(true)
end

function API.HideCursor()
    usageCount = usageCount - 1
    if usageCount <= 0 then
        UI.SetCanCursorInteractWithUI(false)
        UI.SetCursorVisible(false)
    end
end

function OnActionPressed(player, action)
    if action == "Shoot" then
        if UI.IsReticleVisible() then
            UI.SetReticleVisible(false)
        else
            UI.SetReticleVisible(true)
        end
    end
end

Input.actionPressedEvent(OnActionPressed)

UI.PrintToScreen("Hello World!")
UI.PrintToScreen("And now, red", Color.RED)

-- Binding actions for which keys to press to open up the rewards or quest dialog.
local REWARDS_ACTION_NAME = script:GetCustomProperty("RewardsActionName")
local QUESTS_ACTION_NAME = script:GetCustomProperty("QuestsActionName")

local PLAYER = Game.GetLocalPlayer()

local isDialogOpen = false

function Tick()
    if isDialogOpen and not UI.IsRewardsDialogVisible() then
        isDialogOpen = false
        print("Player closed the Reward Points dialog.")
    end
end

function OnActionPressed(player, action)
    if action == REWARDS_ACTION_NAME then
        UI.SetRewardsDialogVisible(true, RewardsDialogTab.REWARD_POINT_GAMES)
    elseif action == QUESTS_ACTION_NAME then
        UI.SetRewardsDialogVisible(true, RewardsDialogTab.QUESTS)
    end
end

Input.actionPressedEvent:Connect(OnActionPressed)

local TRIGGER = script:GetCustomProperty("SocialZone"):WaitForObject()
local UI_PANEL = script:GetCustomProperty("HUDSocialIndicator"):WaitForObject()
local PLAYER = Game.GetLocalPlayer()

function Tick()
    if UI.IsSocialMenuEnabled() then
        UI_PANEL.visibility = Visibility.INHERIT
    else
        UI_PANEL.visibility = Visibility.FORCE_OFF
    end
    Task.Wait(1)
end

TRIGGER.beginOverlapEvent:Connect(function(trigger, other)
    if other == PLAYER then
        UI.SetSocialMenuEnabled(true)
    end
end)

TRIGGER.endOverlapEvent:Connect(function(trigger, other)
    if other == PLAYER then
        UI.SetSocialMenuEnabled(false)
    end
end)

-- Server script:
function OnDamaged(player, dmg)
    local amount = dmg.amount
    local position = nil
    if dmg.sourcePlayer then
        position = dmg.sourcePlayer:GetWorldPosition()
    end
    Events.BroadcastToPlayer(player, "TookDamage", amount, position)
end

Game.playerJoinedEvent:Connect(function(player)
    player.damagedEvent:Connect(OnDamaged)
end)

-- Client script:
function OnDamaged(amount, position)
    if position then
        UI.ShowDamageDirection(position)
    end
end

Events.Connect("TookDamage", OnDamaged)

-- Server script:
function GiveRewardPoints(player, amount)
    player:GrantRewardPoints(amount, "MyRP")

    Events.BroadcastToPlayer(player, "ShowRPGain", amount)
end

-- Client script:
local RP_COLOR = Color.New(0.18, 0.09, 0.36)

function OnShowRPGain(amount)
    local message = "+"..amount.." RP"
    local pos = Game.GetLocalPlayer():GetWorldPosition() + Vector3.UP * 100
    local params = {color = RP_COLOR, isBig = true}
    UI.ShowFlyUpText(message, pos, params)
end
Events.Connect("ShowRPGain", OnShowRPGain)

-- Converts the enum CoreModalType into a string, to make the log more readable
function ToStringModaltype(modalType)
    -- The pause menu opened by pressing the Escape key, or other minor pause states
    if modalType == CoreModalType.PAUSE_MENU then return "PAUSE" end

    -- Popup when the player is choosing a character
    if modalType == CoreModalType.CHARACTER_PICKER then return "CHARACTER PICKER" end

    -- Popup when the player is choosing a mount
    if modalType == CoreModalType.MOUNT_PICKER then return "MOUNT PICKER" end

    -- Popup when the player is choosing an emote
    if modalType == CoreModalType.EMOTE_PICKER then return "EMOTE PICKER" end

    -- Popup when the player is inspecting another player for social actions
    if modalType == CoreModalType.SOCIAL_MENU then return "SOCIAL MENU" end

    -- Fallback, future-proof
    return "???" .. tostring(modalType)
end

function OnModalChanged(modalType)
    if modalType ~= nil then
        print("Modal changed to: " .. ToStringModaltype(modalType))
    else
        print("Closed modal.")
    end
end
UI.coreModalChangedEvent:Connect(OnModalChanged)