How To Create a FiveM Driving School (DMV)

Okay, let’s dive into crafting the ultimate guide for setting up a compelling FiveM Driving School on your server.

Here at QBCore Store LLC, we understand that immersion and structured gameplay are key to a thriving roleplay environment.

A well-implemented Driving School or Department of Motor Vehicles (DMV) isn’t just a hurdle for players; it’s a fantastic opportunity for interaction, roleplay, and establishing fundamental server rules regarding road conduct.

This tutorial will guide you through creating your own FiveM Driving School, exploring various approaches from fully player-managed systems to automated testing.

We’ll break down the concepts, implementation steps, and even provide some sample questions to get you started.

Why Implement a FiveM Driving School (DMV)?

Before we get into the how, let’s quickly touch on the why.

Adding a DMV system to your FiveM server offers numerous benefits:

• Enhanced Roleplay: It creates specific roles (examiners, instructors, applicants) and scenarios, fostering organic interactions.
• Gameplay Structure: It introduces a clear progression path for new players, requiring them to learn the rules before gaining full driving privileges.
• Rule Reinforcement: It provides a natural context to teach and test players on your server’s specific traffic laws and expectations.
• Economic Sink (Optional): License fees can serve as a minor money sink, contributing to your server’s economy.
• Foundation for Advanced Licenses: It lays the groundwork for implementing different license classes (motorcycles, trucks, boats, aircraft) later on.
• Increased Immersion: Simply having a formal process to obtain a license adds a layer of realism that many players appreciate.

Now, let’s explore the different ways you can bring a FiveM Driving School to life.

Approach 1: The Player-Managed FiveM DMV

This is often considered the gold standard for heavy roleplay servers.

It relies entirely on players to staff and operate the DMV, conducting both theory and practical tests.

Concept & Philosophy

The core idea is maximum interaction and roleplay.

Getting a license isn’t just about passing a test; it’s about navigating a bureaucratic process, interacting with government employees (other players), and demonstrating competence through direct evaluation.

This approach puts human judgment and interaction at the forefront.

Requirements & Setup

1. Dedicated Staff: You need reliable players willing to take on roles like:
   • DMV Director/Manager: Oversees operations, sets policies, handles disputes.
   • Administrative Staff: Handles applications, scheduling, paperwork (in-game items or forum posts), and initial information.
   • Theory Examiners: Conducts verbal or written (via chat/forms) theory tests based on server rules.
   • Practical Examiners: Rides along with applicants during a practical driving test, evaluating their skills.
2. Location: A designated physical location is crucial.
   • Consider using a custom FiveM MLO specifically designed as a DMV or government building for maximum immersion.
   • Alternatively, repurpose an existing interior or mark out an area with basic mapping tools.
   • Essential areas include a waiting room, reception desk, offices/interview rooms, and potentially a dedicated theory testing area.
3. Procedures & Rules: Clearly define the entire process:
   • How do players apply? (In-game form, Discord application, forum post?)
   • How are appointments scheduled?
   • What are the steps for the theory test? (Verbal Q&A, multiple-choice form?)
   • What does the practical test involve? (Specific route, maneuvers required?)
   • What are the passing/failing criteria?
   • How are licenses issued/updated? (Requires integration with your framework’s license system).
   • What are the fees involved?
   • What happens if someone fails? (Waiting period, re-test procedure?)
4. Documentation (Optional but Recommended): Create in-game items representing application forms, theory test sheets, practical evaluation forms, and temporary/permanent licenses. This adds a tangible element to the RP.
5. Integration: Ensure your DMV staff have the necessary permissions/commands to grant/revoke licenses within your server framework (ESX Scripts or QBCore Scripts often handle this).

Roleplay Opportunities

This model thrives on RP:

• Nervous applicants interacting with stern examiners.
• Roleplaying the bureaucratic process – filling forms, waiting in line.
• Examiners providing feedback and explaining traffic laws.
• Potential for subtle corruption RP (bribes, favoritism) – handle with care and clear server rules!
• Training scenarios where instructors (players) teach others how to drive before their test.

Pros

• Maximum Roleplay: Offers the deepest level of interaction and immersion.
• Adaptability: Examiners can tailor tests and interactions to the situation.
• Human Judgment: Can assess nuances of driving and understanding that scripts cannot.
• Community Building: Creates dedicated roles and encourages player engagement.

Cons

• Staff Reliant: Heavily dependent on having enough active and reliable players to staff the DMV. Can lead to bottlenecks if staff are unavailable.
• Inconsistency: Different examiners might have slightly different standards or procedures if not managed well.
• Time Consuming: The process can be slow for both applicants and staff.
• Potential for Abuse: Requires oversight to prevent favouritism or unfairness.

Approach 2: Automated Theory Test DMV

This approach uses scripting to handle the knowledge-based part of the driving test.

Players typically interact with a menu or computer terminal to answer multiple-choice questions.

Concept & Philosophy

Efficiency and consistency are the primary goals here.

It ensures every player faces the same standardized theory test based on predefined questions and answers.

This frees up player staff (if any) to focus on other tasks or the practical examination.

Requirements & Setup

1. DMV Script: You’ll need a script designed for this purpose. Many frameworks (ESX, QBCore) have readily available DMV scripts, or you can find standalone options. Check out the extensive collection of FiveM Scripts on QBCore Store LLC – you might find the perfect fit.
2. Configuration: Scripts usually require configuration:
   • Questions & Answers: You MUST define your own set of questions relevant to your server’s rules, map, and general traffic laws. Include correct and incorrect answers for multiple-choice formats.
   • Passing Score: Set the percentage or number of correct answers required to pass.
   • Test Fee: Configure the cost to take the test.
   • Location(s): Define the coordinates where players can access the test (e.g., specific markers, computer props within a building).
   • License Integration: Configure the script to grant a specific license (often a ‘theory passed’ or temporary permit) upon successful completion, or directly the driver’s license if no practical test follows.
   • Cooldown: Set a waiting period before a player can retake the test after failing.
3. Location: While a full MLO is nice, an automated test only strictly needs a marker or interaction point defined in the script. However, placing this within a relevant building enhances immersion.

How It Works (Typical Script Flow)

1. Player approaches the designated test location/marker.
2. Player interacts (presses a key, uses a command).
3. A UI appears, often explaining the test rules and fee.
4. Player pays the fee (if applicable).
5. The test begins: Questions are presented one by one, usually with multiple-choice answers.
6. The script shuffles the question order and potentially the answer order for variety.
7. Player selects their answers.
8. Once all questions are answered, the script calculates the score.
9. The result (Pass/Fail) is displayed.
10. If passed, the script automatically adds the configured license/item to the player’s inventory or data. Money may be deducted.
11. If failed, the script might impose a cooldown period before the player can retry. Money is usually still deducted.

Pros

• Consistency: Every player gets the exact same test based on the configured questions.
• Efficiency: Much faster than player-administered theory tests. Available 24/7.
• Reduced Staff Load: Doesn’t require dedicated player examiners for the theory part.
• Scalability: Handles large numbers of players without bottlenecks (assuming the script is well-optimized).

Cons

• Less Roleplay: Reduces the human interaction element significantly compared to the player-managed approach.
• Potential for Cheating: Players might look up answers externally if questions are too generic or easily searchable. Custom, server-specific questions help mitigate this.
• Rigidity: Cannot adapt to specific player questions or misunderstandings during the test.
• Requires Script: Dependent on finding or developing a suitable and reliable script.

Approach 3: The Practical Driving Test

This is where the rubber meets the road, literally.

It involves evaluating a player’s actual driving ability within the FiveM environment.

This can be supervised by players or, with much greater complexity, partially automated.

Concept & Philosophy

Assess real driving skills: Can the player control a vehicle safely according to server rules?

This includes lane discipline, speed limits, signaling, parking, hazard awareness, and reaction to traffic.

Implementation: Player-Supervised Practical Test

This is the most common and recommended way to handle practical tests, often paired with an automated theory test for a hybrid approach.

1. Examiner Role: Needs a player (DMV staff) to ride along with the applicant.
2. Defined Routes: Predetermine several standardized test routes of varying difficulty. Routes should cover different road types (city, highway), intersections, and require specific maneuvers (e.g., three-point turn, parallel parking).
3. Evaluation Criteria: Create a clear scoring system or checklist for the examiner. Points to evaluate:
   • Speed Control: Adhering to speed limits, adjusting for conditions.
   • Lane Discipline: Staying within lanes, proper lane changes.
   • Signaling: Correctly using turn signals for turns and lane changes.
   • Observation: Checking mirrors, reacting to traffic and pedestrians.
   • Maneuvers: Executing required turns, parking, etc., smoothly and safely.
   • Following Instructions: Responding correctly to the examiner’s directions.
   • Traffic Laws: Obeying stop signs, traffic lights, right-of-way rules.
   • Vehicle Control: Smooth acceleration, braking, steering.
   • Collisions: Any collision usually results in automatic failure.
4. Procedure:
   • Applicant (having passed theory) schedules a practical test.
   • Examiner meets the applicant at the DMV/starting point.
   • Examiner explains the test procedure and expectations.
   • Examiner directs the applicant along the chosen route.
   • Examiner observes and mentally (or physically, using a form/UI) scores the applicant’s driving.
   • Upon returning, the examiner provides feedback and the result (Pass/Fail).
   • If passed, the examiner grants the full driver’s license using appropriate commands.
   • If failed, the examiner explains why and advises on when they can re-test.
5. Vehicle: Usually, the applicant uses a standard, provided DMV test vehicle (e.g., a basic sedan). This ensures fairness.

Implementation: Scripted/Semi-Scripted Practical Test (Advanced)

Automating a practical driving test is technically challenging in FiveM due to the complexities of accurately detecting nuanced driving behaviour and intent.

• Concept: A script would define a route using checkpoints. It would monitor the player’s speed, potentially detect collisions, and check if they stay within waypoints.
• Technical Hurdles:
  • Lane Detection: Reliably detecting if a player is perfectly within their lane is very difficult.
  • Signal Detection: Scripts typically cannot detect turn signal usage accurately across all vehicles.
  • Observation/Awareness: Impossible for a script to judge if a player is checking mirrors or reacting appropriately to unforeseen hazards (like AI behaving erratically).
  • Maneuver Quality: Scripts struggle to assess the quality of a parking job or a turn, only whether checkpoints were hit.
  • Performance: Constantly checking player driving metrics can impact server performance.
• Possible Implementation (Simplified/Hybrid):
  • A script guides the player through checkpoints along a route.
  • It automatically fails the player for excessive speeding (using native speed checks).
  • It automatically fails the player for major collisions (using entity collision events).
  • It might track time taken.
  • Crucially, it likely still requires player supervision for aspects like signaling, observation, and minor errors.
• Verdict: Fully automated practical tests are rare and often clunky. A hybrid approach (script handles route/speed/collision basics, player examiner judges the rest) is more feasible but still complex. Most servers opt for fully player-supervised practical tests.

Pros (Player-Supervised Practical)

• Real Skill Assessment: Provides the best measure of actual driving competence in the game world.
• Direct Feedback: Examiners can give immediate, specific feedback.
• High Roleplay Potential: The interaction during the test is prime RP fuel.
• Adaptable: Examiners can react to unexpected situations (AI crashes, other players interfering).

Cons (Player-Supervised Practical)

• Time Intensive: Requires significant time investment from both examiner and applicant.
• Staff Dependent: Relies on available, trained player examiners.
• Subjectivity: Scoring can sometimes be subjective if criteria aren’t perfectly defined and enforced.
• Potential Bottlenecks: Can create queues if demand exceeds examiner availability.

Choosing Your Approach: Finding the Balance

The best FiveM Driving School system often lies in a hybrid approach:

• Automated Theory Test: Handles the knowledge component efficiently and consistently. Players must pass this first.
• Player-Supervised Practical Test: Required after passing the theory test. This allows for genuine skill assessment and valuable roleplay interaction.

This combination balances efficiency, consistency, roleplay, and genuine skill evaluation.

It ensures players know the rules (theory) and can apply them (practical) before getting their full license.

General Implementation Steps

Regardless of the chosen approach, here’s a general roadmap:

1. Plan: Decide on your approach (Player-Managed, Automated Theory, Practical Test type, Hybrid?). Define the scope (cars only, or other vehicles too?).
2. Select Location: Choose and secure a suitable location. Consider acquiring a custom DMV MLO for the best look and feel.
3. Acquire Scripts/Assets:
   • Find or commission an automated theory test script if needed. Browse the Scripts section on QBCore Store LLC.
   • Ensure you have scripts or framework features to manage licenses (add/remove/check).
   • Consider vehicle scripts if you want specific DMV test cars.
4. Configure: Set up scripts, define questions, answers, passing scores, fees, test routes, and evaluation criteria.
5. Define Procedures: Write clear, step-by-step instructions for players on how to use the DMV system. Document rules for staff if applicable.
6. Staffing (If Applicable): Recruit and train trustworthy players for examiner or administrative roles. Grant them necessary permissions.
7. Testing: Thoroughly test the entire process from a player’s perspective. Test script functionality, roleplay procedures, and license granting.
8. Launch & Announce: Introduce the DMV system to your community. Provide clear guides and information.
9. Iterate: Gather feedback from players and staff. Refine procedures, questions, routes, and scripts based on experience. Perhaps look into complete FiveM Server Packs that might include integrated DMV systems.

Sample FiveM DMV Theory Questions

Creating good theory questions is vital, especially for automated tests.

They should cover general traffic laws and specific server rules.

Mix multiple-choice and true/false questions.

Here are some examples to inspire you:

(General Traffic Laws)

1. When approaching a solid red traffic light, you should:
   • A) Slow down and proceed if clear.
   • B) Stop completely behind the line until the light turns green.
   • C) Stop only if other cars are present.
   • D) Honk your horn before proceeding.
     (Correct: B)
2. True or False: You must always use your turn signal when changing lanes.
   (Correct: True)
3. What is the default speed limit in a residential area unless otherwise posted? (Adjust to your server’s standard)
   • A) 25 MPH
   • B) 35 MPH
   • C) 45 MPH
   • D) 55 MPH
     *(Correct: B – *Adjust as needed)
4. When two vehicles arrive at an uncontrolled four-way stop at the same time, who has the right-of-way?
   • A) The vehicle on the left.
   • B) The vehicle that is larger.
   • C) The vehicle on the right.
   • D) Whoever gets there first, even by a split second.
     (Correct: C)
5. True or False: You are allowed to park facing oncoming traffic.
   (Correct: False)
6. What does a solid yellow line on your side of the road mean?
   • A) Passing is permitted when safe.
   • B) Passing is prohibited.
   • C) The road is ending soon.
   • D) Merging area ahead.
     (Correct: B)
7. When emergency vehicles (police, fire, ambulance) approach with lights and sirens active, you should:
   • A) Speed up to get out of their way.
   • B) Maintain your speed and lane.
   • C) Pull over to the right side of the road and stop until they pass.
   • D) Follow them closely.
     (Correct: C)
8. True or False: It is acceptable to use your horn excessively out of frustration.
   (Correct: False)

(Server Specific Rules – Examples, tailor these heavily!)

9. What is the server rule regarding driving on sidewalks?
   • A) Allowed if traffic is heavy.
   • B) Prohibited at all times unless directed by staff/police RP.
   • C) Allowed for shortcuts.
   • D) Only allowed during pursuits.
     *(Correct: B – *Assuming this is your rule)
10. True or False: According to server rules, ramming other player vehicles intentionally outside of approved RP scenarios is allowed.
    *(Correct: False – *Assuming VDM rules)
11. What is the designated procedure if you accidentally get into a minor fender bender with another player?
    • A) Drive off immediately.
    • B) Stop, get out, and roleplay the interaction (exchange info, call police if needed).
    • C) Immediately message an admin.
    • D) Blame the other driver loudly over voice chat.
      *(Correct: B – *Promote RP interaction)
12. True or False: On this server, you need a special license (e.g., Trucking License) to operate large commercial vehicles.
    *(Correct: True/False – *Depends on your setup)
13. Where is the primary location for the server’s Department of Motor Vehicles (DMV)?
    • A) Near Legion Square.
    • B) In Paleto Bay.
    • C) The specific address defined in server info/map marker.
    • D) There is no physical DMV location.
      *(Correct: C – *Make it specific to your server)
14. Is stunt driving (jumps, excessive drifting) permitted on public roads during normal circumstances on this server?
    • A) Yes, anytime.
    • B) Only on highways.
    • C) No, it’s considered unrealistic/fail RP outside designated areas or events.
    • D) Only if you have a fast car.
      *(Correct: C – *Assuming realistic RP focus)
15. True or False: All players are required to obtain a driver’s license from the DMV before legally driving cars on the server.
    *(Correct: True – *Assuming this is the purpose of your DMV)

Remember to create a pool of 30-50+ questions so the test doesn’t become too repetitive.

Conclusion: Building a Better Road Ahead

Implementing a FiveM Driving School or DMV system is a significant step towards creating a more structured, immersive, and engaging roleplay environment.

Whether you choose a fully player-managed system, rely on automated scripts, or blend the two, the goal is to establish clear expectations for driving conduct and provide meaningful interactions.

It requires careful planning, configuration, and potentially dedicated player staff, but the payoff in roleplay quality and server structure is immense.

By requiring players to learn the rules and demonstrate basic competence, you enhance realism and create a foundation for more complex vehicle and licensing systems down the line.

We hope this detailed guide helps you design and implement the perfect DMV system for your community.

At QBCore Store LLC, we’re dedicated to providing the resources, like high-quality Scripts and MLOs, you need to build the best possible FiveM server.

Good luck on the road!

Frequently Asked Questions (FAQ)

Q1: What’s the best approach for a new server? Automated or Player-Run DMV?

• For new servers, starting with an automated theory test combined with clearly posted server driving rules is often easiest.
• It ensures everyone learns the basics without requiring immediate dedicated staff.
• You can introduce player-supervised practical tests later as your community grows and you identify reliable players for staff roles.

Q2: Can I buy a complete FiveM Driving School script?

• Yes, many developers offer comprehensive DMV scripts, especially for popular frameworks like ESX and QBCore.
• These often include automated theory tests, locations, and sometimes basic frameworks for practical tests or license management.
• Check resources like the QBCore Store LLC store for available options.

Q3: How difficult is it to script an automated practical driving test?

• Very difficult to do well.
• While basic checks like speed limits, checkpoint progression, and collision detection are possible, accurately assessing nuanced driving skills (lane keeping, signaling, observation, smooth control) via script is extremely challenging and often unreliable in the dynamic FiveM environment.
• Most servers rely on player examiners for practical tests.

Q4: What’s a good location for a FiveM DMV?

• Popular choices include repurposing existing government buildings in Los Santos (like the Mission Row PD area or government buildings near Legion Square).
• Using a custom MLO designed specifically as a DMV provides the best immersion. You can find these on sites like QBCore Store LLC.
• Ensure the location has adequate space for waiting, offices, and easy access to varied road types for practical tests.

Q5: How many staff members do I need for a player-run DMV?

• It depends on your server population and how active the DMV is.
• For a small-medium server, starting with 2-3 active and dedicated players who can cover different time zones might be sufficient.
• One could focus on admin/scheduling, while others act as examiners.
• Larger servers might need a bigger team (5+) to handle the volume of applicants without excessive waiting times.

Q6: How do I prevent players from cheating on the automated theory test?

• Custom Questions: Write questions specific to your server’s rules, locations, and lore. These are harder to Google.
• Large Question Pool: Use a large database of questions and randomize which ones appear for each test.
• Randomized Answers: Shuffle the order of multiple-choice answers each time.
• Time Limits: Implement a reasonable time limit per question or for the overall test.
• Cooldowns: Enforce a waiting period after a failed test to discourage rapid-fire guessing.
• While no system is foolproof, these measures significantly deter cheating.

Okay, let’s look at some conceptual code snippets to illustrate parts of a FiveM Driving School setup.

Disclaimer: These are simplified examples to demonstrate concepts.

They are not complete, ready-to-run scripts and will need significant adaptation and integration into your specific server framework (like ESX, QBCore, or a custom one) and chosen UI system.

Assume common FiveM Lua functions and framework events/exports are available.

Code Samples for FiveM Driving School Concepts

1. Basic Theory Question Display (Client-Side Lua Concept)

This snippet imagines using a basic UI element (like NativeUI or a simple NUI frame) to show a question.

-- Client-Side Example (Conceptual)

-- Assume 'ShowTheoryQuestionUI' is a function you create
-- It would take the question text and answer options
-- It should also handle player input (selecting an answer) and trigger an event

local currentQuestionData = {
    question = "What should you do at a solid red traffic light?",
    answers = {
        { id = "A", text = "Speed up if clear" },
        { id = "B", text = "Stop completely before the line" },
        { id = "C", text = "Honk and proceed carefully" },
        { id = "D", text = "Slow down slightly" }
    },
    correctAnswerId = "B"
}

function DisplayQuestion(questionData)
    -- 1. Clear any previous question UI elements
    -- YourUIClearFunction()

    -- 2. Display the question text
    -- YourUIDisplayText(questionData.question)

    -- 3. Display the multiple-choice answers (buttons, list items, etc.)
    for _, answer in ipairs(questionData.answers) do
        -- YourUIDisplayAnswerOption(answer.id, answer.text, function()
        --     -- This callback function is executed when the player selects this answer
        --     print("Player selected answer: " .. answer.id)
        --     TriggerServerEvent('drivingSchool:submitAnswer', currentQuestionData.correctAnswerId, answer.id)
        --     -- Close the UI or move to the next question after submission
        --     -- YourUICloseFunction()
        -- end)
    end

    print("Displayed question: " .. questionData.question)
end

-- Example Usage:
-- DisplayQuestion(currentQuestionData)

-- You would need a system to load questions, manage the test state (current score, question index),
-- and handle the UI interactions fully.

Explanation:

• We define a table currentQuestionData holding the question text, answer options (each with an ID and text), and the ID of the correct answer.
• The DisplayQuestion function is a placeholder for your actual UI logic.
• It would dynamically create UI elements for the question and answers.
• Crucially, each answer option needs a callback function that triggers when selected.
• This callback typically sends the player’s chosen answer ID and the correct answer ID to the server for validation using TriggerServerEvent.

2. Checking Answer on Server (Server-Side Lua Concept)

This snippet shows how the server might receive the answer and check it.

-- Server-Side Example (Conceptual)

-- Assume you have a way to track player test progress, maybe in a table:
-- local playerTestStates = {} -- Key: player source, Value: { score, currentQuestionIndex, etc. }

RegisterNetEvent('drivingSchool:submitAnswer')
AddEventHandler('drivingSchool:submitAnswer', function(correctAnswerId, submittedAnswerId)
    local src = source -- Get the player who sent the event

    print("Received answer from player " .. src .. ". Correct: " .. correctAnswerId .. ", Submitted: " .. submittedAnswerId)

    -- Ensure the player is actually taking a test (check playerTestStates)
    -- if not playerTestStates[src] then return end

    local wasCorrect = (correctAnswerId == submittedAnswerId)

    if wasCorrect then
        print("Player " .. src .. " answered correctly!")
        -- Increment player's score
        -- playerTestStates[src].score = playerTestStates[src].score + 1
        -- Notify player of correct answer (optional)
        -- TriggerClientEvent('chat:addMessage', src, { args = {"^2Correct!"} })
    else
        print("Player " .. src .. " answered incorrectly.")
        -- Notify player of incorrect answer (optional)
        -- TriggerClientEvent('chat:addMessage', src, { args = {"^1Incorrect."} })
    end

    -- Logic to proceed to the next question or finish the test
    -- MoveToNextQuestionOrEndTest(src)
end)

-- Placeholder for function to manage test flow
-- function MoveToNextQuestionOrEndTest(playerId)
--     -- 1. Check if there are more questions
--     -- 2. If yes, get next question data and TriggerClientEvent to display it
--     -- 3. If no, calculate final score, check if passed, grant license/cooldown, clean up state
-- end

Explanation:

• We register a network event drivingSchool:submitAnswer that the client triggers.
• The event handler receives the correct ID and the ID the player submitted.
• It compares the two IDs to see if the answer was correct.
• Based on the result, it would update the player’s score (stored server-side, e.g., in playerTestStates), potentially notify the player, and then trigger the logic to either show the next question or conclude the test.

3. Granting License (Server-Side – ESX/QBCore Examples)

Here’s how you might grant a license using common framework functions after a player successfully passes the test(s).

-- Server-Side Example (Conceptual - ESX)

-- Function called when player passes the test
function GrantDriverLicenseESX(playerId)
    local xPlayer = ESX.GetPlayerFromId(playerId)

    if xPlayer then
        -- Assuming 'dmv' is the license name configured in licenses table
        xPlayer.addLicense('dmv', function(success)
            if success then
                print("Successfully granted 'dmv' license to player " .. playerId)
                -- Notify player
                TriggerClientEvent('esx:showNotification', playerId, 'You have received your Driver\'s License!')
                -- Potentially charge a fee here if not done earlier
                -- xPlayer.removeMoney(DMV_LICENSE_FEE)
            else
                print("Failed to grant 'dmv' license to player " .. playerId .. " (already possessed?)")
                TriggerClientEvent('esx:showNotification', playerId, 'Error: Could not grant license. Do you already have it?')
            end
        end)
    else
        print("Error: Could not find player with ID " .. playerId .. " to grant license.")
    end
end

-- Example Usage (inside the test completion logic):
-- if finalScore >= passingScore then
--     GrantDriverLicenseESX(src)
-- end

-- Server-Side Example (Conceptual - QBCore)

-- Function called when player passes the test
function GrantDriverLicenseQBCore(playerId)
    local Player = QBCore.Functions.GetPlayer(playerId)

    if Player then
        -- Assuming 'driver' is the license type identifier in QBCore shared config
        local licenseType = 'driver'
        local hasLicense = Player.Functions.GetLicense(licenseType)

        if not hasLicense then
            local success = Player.Functions.AddLicense(licenseType)
            if success then
                print("Successfully granted '" .. licenseType .. "' license to player " .. playerId)
                -- Notify player
                TriggerClientEvent('QBCore:Notify', playerId, 'You have received your Driver\'s License!', 'success')
                -- Potentially charge a fee here if not done earlier
                -- Player.Functions.RemoveMoney('cash', DMV_LICENSE_FEE, 'dmv-license-fee')
            else
                -- This else might not be reachable if AddLicense always returns true or errors out
                print("Failed to grant '" .. licenseType .. "' license to player " .. playerId)
                TriggerClientEvent('QBCore:Notify', playerId, 'Error: Could not grant license.', 'error')
            end
        else
            print("Player " .. playerId .. " already has the '" .. licenseType .. "' license.")
            TriggerClientEvent('QBCore:Notify', playerId, 'You already possess a Driver\'s License.', 'inform')
        end
    else
        print("Error: Could not find player with ID " .. playerId .. " to grant license.")
    end
end

-- Example Usage (inside the test completion logic):
-- if finalScore >= passingScore then
--     GrantDriverLicenseQBCore(src)
-- end

Explanation:

• These functions take the player’s server ID (playerId or src).
• They use the specific framework’s functions (ESX.GetPlayerFromId, QBCore.Functions.GetPlayer) to get the player object.
• They then call the appropriate license-granting function (xPlayer.addLicense for ESX, Player.Functions.AddLicense for QBCore). You need to know the exact name/identifier used for the driver’s license in your framework’s configuration.
• Callbacks or return values are used to confirm success and notify the player.
• Error handling for missing players or existing licenses is included.

4. Practical Test Checkpoint Detection (Client-Side Lua)

This shows a basic loop to check if the player is near a specific coordinate (a checkpoint).

-- Client-Side Example (Conceptual)

local practicalTestCheckpoints = {
    vector3(150.0, -1000.0, 30.0), -- Example coordinates
    vector3(250.0, -1050.0, 30.0),
    -- Add more checkpoints for the route
}
local currentCheckpointIndex = 1
local checkpointMarkerHandle = nil -- To store the marker handle
local markerDetectionRange = 3.0 -- How close the player needs to be

Citizen.CreateThread(function()
    while true do
        -- Sleep the thread for performance
        Citizen.Wait(500) -- Check every 500ms

        -- Only run if the player is actually on the practical test
        -- if not isPlayerOnPracticalTest then Citizen.Wait(2000) goto continue end -- Skip if not on test

        local playerPed = PlayerPedId()
        local playerCoords = GetEntityCoords(playerPed)
        local targetCheckpoint = practicalTestCheckpoints[currentCheckpointIndex]

        if targetCheckpoint then
            local distance = #(playerCoords - targetCheckpoint) -- Calculate distance using Vdist

            -- Draw a marker at the checkpoint location (optional visual aid)
            DrawMarker(1, targetCheckpoint.x, targetCheckpoint.y, targetCheckpoint.z - 1.0, 0.0, 0.0, 0.0, 0.0, 180.0, 0.0, 2.0, 2.0, 2.0, 255, 255, 0, 100, false, true, 2, nil, nil, false)

            if distance < markerDetectionRange then
                print("Player reached checkpoint " .. currentCheckpointIndex)
                currentCheckpointIndex = currentCheckpointIndex + 1

                -- Check if this was the last checkpoint
                if currentCheckpointIndex > #practicalTestCheckpoints then
                    print("Practical test route completed!")
                    -- Trigger server event to notify completion
                    TriggerServerEvent('drivingSchool:practicalRouteComplete')
                    -- Stop the test logic here
                    -- isPlayerOnPracticalTest = false
                else
                    print("Proceeding to next checkpoint: " .. currentCheckpointIndex)
                    -- Maybe provide navigation to the next point
                end
            end
        end
        -- ::continue:: -- Used with the goto skip above
    end
end)

Explanation:

• We define a list (practicalTestCheckpoints) of coordinates representing the test route.
• A loop runs periodically (Citizen.Wait).
• It gets the player’s current coordinates.
• It calculates the distance to the current target checkpoint.
• It draws a visual marker at the checkpoint location using DrawMarker.
• If the distance is within the markerDetectionRange, it increments currentCheckpointIndex to move to the next checkpoint.
• When the last checkpoint is reached, it signifies route completion.

5. Vehicle Speed Check (Client-Side Lua)

A simple snippet to get the current speed of the vehicle the player is in.

-- Client-Side Example (Conceptual)

function GetCurrentSpeedMPH()
    local playerPed = PlayerPedId()
    local vehicle = GetVehiclePedIsIn(playerPed, false)

    if vehicle ~= 0 then -- Check if the player is actually in a vehicle
        local speed = GetEntitySpeed(vehicle) -- Speed in meters per second

        -- Convert m/s to MPH (1 m/s = 2.23694 MPH)
        local speedMPH = speed * 2.23694

        return speedMPH
    end

    return 0 -- Return 0 if not in a vehicle
end

-- Example usage within a loop or check:
-- Citizen.CreateThread(function()
--     while true do
--         Citizen.Wait(1000) -- Check every second
--         local currentSpeed = GetCurrentSpeedMPH()
--         print("Current Speed: " .. string.format("%.2f", currentSpeed) .. " MPH")

--         -- Add logic here to check against speed limits for the practical test
--         -- if currentSpeed > CURRENT_ROUTE_SPEED_LIMIT then
--         --     TriggerServerEvent('drivingSchool:reportSpeeding', currentSpeed)
--         -- end
--     end
-- end)

Explanation:

• The GetCurrentSpeedMPH function checks if the player is in a vehicle using GetVehiclePedIsIn.
• If they are, it gets the vehicle’s speed in meters per second using GetEntitySpeed.
• It converts this speed to Miles Per Hour (MPH). You could easily adjust the multiplier for Kilometers Per Hour (KPH ≈ 3.6).
• The example thread shows how you might periodically call this function to monitor speed, potentially comparing it against a limit and notifying the server if exceeded during a practical test.

Remember, these are foundational building blocks.

A complete FiveM Driving School script involves much more: robust UI design, state management, handling edge cases (player disconnects, vehicle destruction), framework integration, configuration files, and thorough testing.