-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]


--========================================================
-- GTA STYLE LIVE MINIMAP V2
-- LOCAL CLIENT / EXECUTOR
-- Features:
--  * Live road geometry from game modules
--  * Heading-up map
--  * Large high-contrast player marker
--  * Thicker roads
--  * Drag map by header
--  * Resize with +/- buttons
--  * Resize by dragging bottom-right corner
--========================================================

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")

local LP = Players.LocalPlayer
local PlayerGui = LP:WaitForChild("PlayerGui")

local GUI_NAME = "GTAMinimapV2"
local BIND_NAME = "GTAMinimapV2_Update"

--========================================================
-- CLEAN PREVIOUS VERSION
--========================================================

if _G.GTAMinimapV2Cleanup then
    pcall(_G.GTAMinimapV2Cleanup)
end

local connections = {}

local function Connect(signal, callback)
    local connection = signal:Connect(callback)
    table.insert(connections, connection)
    return connection
end

local function Cleanup()
    pcall(function()
        RunService:UnbindFromRenderStep(BIND_NAME)
    end)

    for _, connection in ipairs(connections) do
        pcall(function()
            connection:Disconnect()
        end)
    end

    local old = PlayerGui:FindFirstChild(GUI_NAME)
    if old then
        old:Destroy()
    end
end

_G.GTAMinimapV2Cleanup = Cleanup

Cleanup()

--========================================================
-- SETTINGS
--========================================================

local MAP_SIZE = 235

local MIN_SIZE = 150
local MAX_SIZE = 350
local SIZE_STEP = 20

local UPDATE_RATE = 0.08
local MAP_PADDING = 0

local ROAD_WIDTH = 15.2
local ROAD_OUTLINE_WIDTH = 8

local COLORS = {
    Background = Color3.fromRGB(43, 48, 49),

    Road = Color3.fromRGB(220, 222, 216),
    RoadOutline = Color3.fromRGB(18, 21, 23),

    Player = Color3.fromRGB(45, 190, 255),
    PlayerOutline = Color3.fromRGB(255, 255, 255),

    Header = Color3.fromRGB(29, 34, 36),
    Text = Color3.fromRGB(235, 239, 239),
    Muted = Color3.fromRGB(155, 165, 166),
}

--========================================================
-- LOAD ORIGINAL GAME ROAD MODULES
--========================================================

local Shared = ReplicatedStorage:WaitForChild("Shared", 10)
assert(Shared, "Shared folder unavailable")

local Config = Shared:WaitForChild("Config")
local Rules = Shared:WaitForChild("Rules")

local RadarConfig = require(Config:WaitForChild("Radar"))
local WorldConfig = require(Config:WaitForChild("World"))

local RadarRules = require(Rules:WaitForChild("Radar"))
local RoadPathModule = require(Rules:WaitForChild("RoadPath"))

local RoadPath = RoadPathModule.build(WorldConfig)

local Bitmap = RadarConfig.Bitmap

local WORLD_SCALE = Bitmap.Radius / RadarConfig.Range

-- Vehicle controller
local CarController

pcall(function()
    local Client = LP:WaitForChild("PlayerScripts")
        :WaitForChild("Client")

    CarController = require(Client:WaitForChild("CarController"))
end)

--========================================================
-- VEHICLE DETECTION
--========================================================

local function GetChassis()

    if CarController then
        local success, chassis = pcall(function()
            return CarController.viewChassis()
        end)

        if success
            and typeof(chassis) == "Instance"
            and chassis:IsA("BasePart") then

            return chassis
        end
    end

    local character = LP.Character
    if not character then
        return nil
    end

    local humanoid = character:FindFirstChildOfClass("Humanoid")
    local seat = humanoid and humanoid.SeatPart

    if not seat then
        return nil
    end

    local model = seat:FindFirstAncestorOfClass("Model")

    while model
        and model.Parent
        and model.Parent:IsA("Model") do

        model = model.Parent
    end

    if model then
        local chassis = model:FindFirstChild("Chassis", true)

        if chassis and chassis:IsA("BasePart") then
            return chassis
        end
    end

    return nil
end

--========================================================
-- GUI HELPERS
--========================================================

local function Create(class, properties, parent)

    local object = Instance.new(class)

    for key, value in pairs(properties) do
        object[key] = value
    end

    object.Parent = parent

    return object
end

local GUI = Create("ScreenGui", {
    Name = GUI_NAME,
    ResetOnSpawn = false,
    IgnoreGuiInset = true,
    DisplayOrder = 999,
}, PlayerGui)

--========================================================
-- MAIN CONTAINER
--========================================================

local Container = Create("Frame", {
    Name = "GPS",
    AnchorPoint = Vector2.new(0, 1),

    Position = UDim2.new(0, 22, 1, -22),

    Size = UDim2.fromOffset(
        MAP_SIZE + 20,
        MAP_SIZE + 51
    ),

    BackgroundColor3 = COLORS.Header,
    BorderSizePixel = 0,
    ClipsDescendants = false,
}, GUI)

Create("UICorner", {
    CornerRadius = UDim.new(0, 10)
}, Container)

Create("UIStroke", {
    Color = Color3.fromRGB(105, 115, 118),
    Thickness = 1,
    Transparency = 0.25,
}, Container)

--========================================================
-- HEADER / DRAG HANDLE
--========================================================

local Header = Create("TextButton", {
    Name = "DragHandle",

    Position = UDim2.fromOffset(0, 0),
    Size = UDim2.new(1, -64, 0, 27),

    BackgroundColor3 = COLORS.Header,
    BackgroundTransparency = 0,
    BorderSizePixel = 0,

    Text = "  GTA GPS",
    TextColor3 = COLORS.Text,
    TextSize = 12,
    Font = Enum.Font.GothamBold,
    TextXAlignment = Enum.TextXAlignment.Left,

    AutoButtonColor = false,
    ZIndex = 5,
}, Container)

-- Minus button
local Minus = Create("TextButton", {
    Name = "DecreaseSize",

    AnchorPoint = Vector2.new(1, 0),
    Position = UDim2.new(1, -35, 0, 3),
    Size = UDim2.fromOffset(26, 21),

    BackgroundColor3 = Color3.fromRGB(65, 72, 75),
    BorderSizePixel = 0,

    Text = "−",
    TextColor3 = COLORS.Text,
    TextSize = 17,
    Font = Enum.Font.GothamBold,

    AutoButtonColor = true,
    ZIndex = 7,
}, Container)

Create("UICorner", {
    CornerRadius = UDim.new(0, 5)
}, Minus)

-- Plus button
local Plus = Create("TextButton", {
    Name = "IncreaseSize",

    AnchorPoint = Vector2.new(1, 0),
    Position = UDim2.new(1, -5, 0, 3),
    Size = UDim2.fromOffset(26, 21),

    BackgroundColor3 = Color3.fromRGB(65, 72, 75),
    BorderSizePixel = 0,

    Text = "+",
    TextColor3 = COLORS.Text,
    TextSize = 16,
    Font = Enum.Font.GothamBold,

    AutoButtonColor = true,
    ZIndex = 7,
}, Container)

Create("UICorner", {
    CornerRadius = UDim.new(0, 5)
}, Plus)

--========================================================
-- MAP SURFACE
--========================================================

local Map = Create("Frame", {
    Name = "MapSurface",

    Position = UDim2.fromOffset(10, 30),
    Size = UDim2.fromOffset(MAP_SIZE, MAP_SIZE),

    BackgroundColor3 = COLORS.Background,
    BorderSizePixel = 0,

    ClipsDescendants = true,
    ZIndex = 1,
}, Container)

Create("UICorner", {
    CornerRadius = UDim.new(0, 5)
}, Map)

--========================================================
-- PLAYER MARKER
--========================================================

local MarkerSize = 0

local MarkerBacking = Create("Frame", {
    Name = "PlayerBacking",

    AnchorPoint = Vector2.new(0.5, 0.5),
    Position = UDim2.fromOffset(
        MAP_SIZE / 2,
        MAP_SIZE / 2
    ),

    Size = UDim2.fromOffset(MarkerSize, MarkerSize),

    BackgroundColor3 = Color3.fromRGB(12, 20, 24),
    BorderSizePixel = 0,
    ZIndex = 20,
}, Map)

Create("UICorner", {
    CornerRadius = UDim.new(1, 0)
}, MarkerBacking)

Create("UIStroke", {
    Color = COLORS.PlayerOutline,
    Thickness = 2,
    Transparency = 0,
}, MarkerBacking)

local Marker = Create("TextLabel", {
    Name = "PlayerArrow",

    AnchorPoint = Vector2.new(0.5, 0.5),
    Position = UDim2.fromScale(0.5, 0.5),

    Size = UDim2.fromScale(1, 1),

    BackgroundTransparency = 1,

    Text = "▲",
    TextColor3 = COLORS.Player,
    TextStrokeColor3 = Color3.fromRGB(0, 0, 0),
    TextStrokeTransparency = 0,

    TextSize = 29,
    Font = Enum.Font.GothamBlack,

    ZIndex = 21,
}, MarkerBacking)

--========================================================
-- COMPASS
--========================================================

local North = Create("TextLabel", {
    Name = "Compass",

    Position = UDim2.fromOffset(7, 6),
    Size = UDim2.fromOffset(20, 18),

    BackgroundColor3 = Color3.fromRGB(20, 25, 27),
    BackgroundTransparency = 0.1,

    Text = "N",
    TextColor3 = COLORS.Text,
    TextSize = 11,
    Font = Enum.Font.GothamBold,

    ZIndex = 15,
}, Map)

Create("UICorner", {
    CornerRadius = UDim.new(0, 4)
}, North)

--========================================================
-- STATUS
--========================================================

local Status = Create("TextLabel", {
    Name = "GPSStatus",

    Position = UDim2.fromOffset(10, MAP_SIZE + 32),
    Size = UDim2.new(1, -35, 0, 14),

    BackgroundTransparency = 1,

    Text = "GPS // INITIALIZING",
    TextColor3 = COLORS.Muted,

    TextSize = 10,
    Font = Enum.Font.GothamMedium,
    TextXAlignment = Enum.TextXAlignment.Left,
}, Container)

--========================================================
-- RESIZE HANDLE
--========================================================

local ResizeHandle = Create("TextButton", {
    Name = "ResizeGrip",

    AnchorPoint = Vector2.new(1, 1),
    Position = UDim2.new(1, -3, 1, -3),

    Size = UDim2.fromOffset(20, 18),

    BackgroundTransparency = 1,

    Text = "◢",
    TextColor3 = COLORS.Muted,
    TextSize = 15,
    Font = Enum.Font.GothamBold,

    AutoButtonColor = false,
    ZIndex = 10,
}, Container)

--========================================================
-- LIVE SIZE MANAGEMENT
--========================================================

local function ApplySize(newSize)

    MAP_SIZE = math.clamp(
        math.floor(newSize),
        MIN_SIZE,
        MAX_SIZE
    )

    Container.Size = UDim2.fromOffset(
        MAP_SIZE + 20,
        MAP_SIZE + 51
    )

    Map.Position = UDim2.fromOffset(10, 30)

    Map.Size = UDim2.fromOffset(
        MAP_SIZE,
        MAP_SIZE
    )

    MarkerBacking.Position = UDim2.fromOffset(
        MAP_SIZE / 2,
        MAP_SIZE / 2
    )

    MarkerSize = math.clamp(MAP_SIZE * 0, 0, 0)

    MarkerBacking.Size = UDim2.fromOffset(
        MarkerSize,
        MarkerSize
    )

    Marker.TextSize = 35

    Status.Position = UDim2.fromOffset(
        10,
        MAP_SIZE + 32
    )

    North.Position = UDim2.fromOffset(7, 6)
end

Connect(Minus.Activated, function()
    ApplySize(MAP_SIZE - SIZE_STEP)
end)

Connect(Plus.Activated, function()
    ApplySize(MAP_SIZE + SIZE_STEP)
end)

--========================================================
-- DRAG AND RESIZE CONTROLS
--========================================================

local interaction = nil

local function StartInteraction(handle, mode)

    Connect(handle.InputBegan, function(input)

        local inputType = input.UserInputType

        if inputType ~= Enum.UserInputType.MouseButton1
            and inputType ~= Enum.UserInputType.Touch then
            return
        end

        interaction = {
            mode = mode,
            inputType = inputType,

            startPointer = input.Position,

            startPosition = Container.Position,
            startSize = MAP_SIZE,
        }
    end)
end

-- Drag by header
StartInteraction(Header, "drag")

-- Resize by corner
StartInteraction(ResizeHandle, "resize")

Connect(UserInputService.InputChanged, function(input)

    if not interaction then
        return
    end

    local isMouse =
        interaction.inputType == Enum.UserInputType.MouseButton1
        and input.UserInputType == Enum.UserInputType.MouseMovement

    local isTouch =
        interaction.inputType == Enum.UserInputType.Touch
        and input.UserInputType == Enum.UserInputType.Touch

    if not isMouse and not isTouch then
        return
    end

    local delta = input.Position - interaction.startPointer

    if interaction.mode == "drag" then

        local start = interaction.startPosition

        Container.Position = UDim2.new(
            start.X.Scale,
            start.X.Offset + delta.X,

            start.Y.Scale,
            start.Y.Offset + delta.Y
        )

    elseif interaction.mode == "resize" then

        local change = (delta.X + delta.Y) * 0.5

        ApplySize(interaction.startSize + change)

    end
end)

Connect(UserInputService.InputEnded, function(input)

    if not interaction then
        return
    end

    if input.UserInputType == interaction.inputType then
        interaction = nil
    end
end)

--========================================================
-- ROAD DRAWING
--========================================================

local Segments = {}

local function NewSegment()

    local outline = Create("Frame", {
        Name = "RoadOutline",

        AnchorPoint = Vector2.new(0.5, 0.5),

        BackgroundColor3 = COLORS.RoadOutline,
        BorderSizePixel = 0,

        Visible = false,
        ZIndex = 3,
    }, Map)

    local road = Create("Frame", {
        Name = "Road",

        AnchorPoint = Vector2.new(0.5, 0.5),

        BackgroundColor3 = COLORS.Road,
        BorderSizePixel = 0,

        Visible = false,
        ZIndex = 4,
    }, Map)

    return {
        Outline = outline,
        Road = road,
    }
end

local function DrawSegment(index, x1, y1, x2, y2)

    local item = Segments[index]

    if not item then
        item = NewSegment()
        Segments[index] = item
    end

    local dx = x2 - x1
    local dy = y2 - y1

    local length = math.sqrt(dx * dx + dy * dy)

    if length < 0.5 then
        item.Outline.Visible = false
        item.Road.Visible = false
        return
    end

    local position = UDim2.fromOffset(
        (x1 + x2) * 0.5,
        (y1 + y2) * 0.5
    )

    local rotation = math.deg(math.atan2(dy, dx))

    item.Outline.Position = position
    item.Outline.Size = UDim2.fromOffset(
        length,
        ROAD_OUTLINE_WIDTH * (MAP_SIZE / 235)
    )
    item.Outline.Rotation = rotation
    item.Outline.Visible = true

    item.Road.Position = position
    item.Road.Size = UDim2.fromOffset(
        length,
        ROAD_WIDTH * (MAP_SIZE / 235)
    )
    item.Road.Rotation = rotation
    item.Road.Visible = true
end

local function HideUnused(count)

    for index = count + 1, #Segments do
        Segments[index].Outline.Visible = false
        Segments[index].Road.Visible = false
    end
end

--========================================================
-- ORIGINAL ROAD GEOMETRY
--========================================================

local function UpdateRoad(chassis)

    local progress = RoadPathModule.project(
        RoadPath,
        chassis.Position.X,
        chassis.Position.Z
    )

    if typeof(progress) ~= "number" then
        HideUnused(0)
        return false
    end

    -- The same road-line generator as PassengerRadar.
    local worldPoints = RadarRules.roadLine(
        RoadPathModule,
        RoadPath,
        progress,
        RadarConfig
    )

    local points = {}

    local factor = MAP_SIZE / (Bitmap.Radius * 2)

    for _, worldPoint in ipairs(worldPoints) do

        -- Original game coordinate conversion.
        -- Coordinates are relative to vehicle orientation,
        -- so the map automatically rotates with the car.

        local x, y = RadarRules.toRadar(
            chassis.CFrame,
            worldPoint,
            WORLD_SCALE
        )

        if typeof(x) == "number" and typeof(y) == "number" then

            table.insert(points, {
                x = MAP_SIZE / 2 + x * factor,
                y = MAP_SIZE / 2 + y * factor,
            })

        end
    end

    local count = 0

    for index = 1, #points - 1 do

        local a = points[index]
        local b = points[index + 1]

        -- Ignore completely distant segments.
        if math.abs(a.x - MAP_SIZE / 2) < MAP_SIZE * 2
            or math.abs(b.x - MAP_SIZE / 2) < MAP_SIZE * 2 then

            if math.abs(a.y - MAP_SIZE / 2) < MAP_SIZE * 2
                or math.abs(b.y - MAP_SIZE / 2) < MAP_SIZE * 2 then

                count += 1

                DrawSegment(
                    count,
                    a.x, a.y,
                    b.x, b.y
                )
            end
        end
    end

    HideUnused(count)

    return count > 0
end

--========================================================
-- MAIN LOOP
--========================================================

local timer = 0

local function Update(dt)

    timer += dt

    if timer < UPDATE_RATE then
        return
    end

    timer = 0

    local chassis = GetChassis()

    if not chassis or not chassis.Parent then

        Status.Text = "GPS // NO VEHICLE"

        HideUnused(0)

        return
    end

    -- The compass rotates to show the north direction.
    local look = chassis.CFrame.LookVector

    local heading = math.deg(
        math.atan2(-look.X, -look.Z)
    )

    North.Rotation = heading

    -- Marker remains at the center, facing forward.
    Marker.Rotation = 0
    MarkerBacking.Rotation = 0

    local success, result = pcall(function()
        return UpdateRoad(chassis)
    end)

    if not success then

        Status.Text = "GPS // ROAD ERROR"

        HideUnused(0)

        warn("[GTAMinimapV2] Road calculation error:", result)

        return
    end

    if result then
        Status.Text = "GPS // LIVE"
    else
        Status.Text = "GPS // NO ROAD"
    end
end

--========================================================
-- START
--========================================================

ApplySize(MAP_SIZE)

RunService:BindToRenderStep(
    BIND_NAME,
    Enum.RenderPriority.Last.Value,
    Update
)

print("--------------------------------------")
print("[GTAMinimapV2] Started")
print("[GTAMinimapV2] Drag header to move")
print("[GTAMinimapV2] +/- buttons change size")
print("[GTAMinimapV2] Drag bottom-right to resize")
print("[GTAMinimapV2] Live local road geometry")
print("--------------------------------------")