[Bug] Teleport to a Waypoint in TypeScript

[i20h]

Summary

I ported the vMenu waypoint teleportation feature to a empty TS project for some test, but this one only works half the time when you're in a vehicle

Issue type

Client

Repro rate

Always

Server build version

FXServer-early-access b96 win32

OS

Windows 11 24h2

CPU

No response

GPU

No response

RAM

No response

Storage type

None

Connection type

None

ISP and bandwidth

No response

DxDiag

No response

Network graph

No response

Platform

None

OS version / distribution

No response

CPU

No response

RAM

No response

Using txAdmin?

None

Hosting provider

None

Machine type

None

/perf endpoint output

No response

DDoS protection

No response

ulimit -n value (Linux only)

No response

Docker Compose file (Docker only)

No response

Steps to Reproduce

1. Start a TypeScript projet with this dependencies :
   "@citizenfx/client": "2.0.33230-1",
   "ts-loader": "^9.5.2",
   "typescript": "^5.9.3",
   "webpack": "^5.97.1",
   "webpack-cli": "^6.0.1"
2. Build the following code
3. Run the “tpm” command in complex areas and areas not far from the player

index.ts

import { teleportToWaypoint } from './teleport';

let teleporting = false;

RegisterCommand(
    'tpm',
    async () => {
        if (teleporting || !IsScreenFadedIn() || IsPlayerSwitchInProgress()) {
            return;
        }

        teleporting = true;
        try {
            await teleportToWaypoint();
        } finally {
            teleporting = false;
        }
    },
    false,
);

teleport.ts

export interface Vector3 {
    x: number;
    y: number;
    z: number;
}

export const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));

function log(message: string): void {
    console.log(`[tpm] ${message}`);
}

export function getVehicle(ped: number = PlayerPedId(), lastVehicle = false): number {
    const veh = GetVehiclePedIsIn(ped, lastVehicle);
    return DoesEntityExist(veh) ? veh : 0;
}

export function getWaypointPosition(): Vector3 | null {
    if (!IsWaypointActive()) {
        return null;
    }

    const iterator = GetBlipInfoIdIterator();
    for (let blip = GetFirstBlipInfoId(iterator); DoesBlipExist(blip); blip = GetNextBlipInfoId(iterator)) {
        if (GetBlipInfoIdType(blip) !== 4) {
            continue;
        }

        const [x, y] = GetBlipInfoIdCoord(blip);

        RequestCollisionAtCoord(x, y, 1000.0);
        const [, groundZ] = GetGroundZFor_3dCoord(x, y, 1000.0, false);

        return { x, y, z: groundZ };
    }

    return null;
}

export async function teleportToCoords(pos: Vector3, safeModeDisabled = false): Promise<void> {
    const playerPed = PlayerPedId();

    if (safeModeDisabled) {
        RequestCollisionAtCoord(pos.x, pos.y, pos.z);

        const currentVehicle = getVehicle(playerPed);
        if (currentVehicle !== 0 && GetPedInVehicleSeat(currentVehicle, -1) === playerPed) {
            SetEntityCoords(currentVehicle, pos.x, pos.y, pos.z, false, false, false, true);
        } else {
            SetEntityCoords(playerPed, pos.x, pos.y, pos.z, false, false, false, true);
        }
        return;
    }

    const veh = getVehicle(playerPed);
    const inVehicle = (): boolean =>
        veh !== 0 && DoesEntityExist(veh) && GetPedInVehicleSeat(veh, -1) === playerPed;

    const vehicleRestoreVisibility = inVehicle() && IsEntityVisible(veh);
    const pedRestoreVisibility = IsEntityVisible(playerPed);

    if (inVehicle()) {
        FreezeEntityPosition(veh, true);
        if (IsEntityVisible(veh)) {
            NetworkFadeOutEntity(veh, true, false);
        }
    } else {
        ClearPedTasksImmediately(playerPed);
        FreezeEntityPosition(playerPed, true);
        if (IsEntityVisible(playerPed)) {
            NetworkFadeOutEntity(playerPed, true, false);
        }
    }

    DoScreenFadeOut(500);
    while (!IsScreenFadedOut()) {
        await delay(0);
    }

    let tempTimer: number;
    let found = false;
    let groundZ = 850.0;

    for (let zz = 950.0; zz >= 0.0; zz -= 25.0) {
        const z = zz % 2 !== 0 ? 950.0 - zz : zz;

        RequestCollisionAtCoord(pos.x, pos.y, z);
        SetFocusPosAndVel(pos.x, pos.y, pos.z, 0, 0, 0);
        NewLoadSceneStart(pos.x, pos.y, pos.z, pos.x, pos.y, pos.z, 50.0, 0);

        tempTimer = GetGameTimer();

        while (!IsNewLoadSceneLoaded() && GetGameTimer() - tempTimer < 3000) {
            await delay(0);
        }

        ClearFocus();
        NewLoadSceneStop();

        if (inVehicle()) {
            SetEntityCoords(veh, pos.x, pos.y, z, false, false, false, true);
        } else {
            SetEntityCoords(playerPed, pos.x, pos.y, z, false, false, false, true);
        }

        tempTimer = GetGameTimer();

        while (!HasCollisionLoadedAroundEntity(playerPed)) {
            if (GetGameTimer() - tempTimer > 1000) {
                log('Waiting for the collision is taking too long (more than 1s). Breaking from wait loop.');
                break;
            }
            await delay(0);
        }

        [found, groundZ] = GetGroundZFor_3dCoord(pos.x, pos.y, z, false);

        if (found) {
            log(`Ground coordinate found: ${groundZ}`);
            if (inVehicle()) {
                SetEntityCoords(veh, pos.x, pos.y, groundZ, false, false, false, true);

                FreezeEntityPosition(veh, false);
                SetVehicleOnGroundProperly(veh);
                FreezeEntityPosition(veh, true);
            } else {
                SetEntityCoords(playerPed, pos.x, pos.y, groundZ, false, false, false, true);
            }
            break;
        }

        await delay(10);
    }

    if (!found) {
        const [, node] = GetNthClosestVehicleNode(pos.x, pos.y, pos.z, 0, 0, 0, 0);
        const safePos: Vector3 = { x: node[0], y: node[1], z: node[2] };

        log('Could not find a safe ground coord. Placing you on the nearest road instead.');

        if (inVehicle()) {
            SetEntityCoords(veh, safePos.x, safePos.y, safePos.z, false, false, false, true);
            FreezeEntityPosition(veh, false);
            SetVehicleOnGroundProperly(veh);
            FreezeEntityPosition(veh, true);
        } else {
            SetEntityCoords(playerPed, safePos.x, safePos.y, safePos.z, false, false, false, true);
        }
    }

    if (inVehicle()) {
        if (vehicleRestoreVisibility) {
            NetworkFadeInEntity(veh, true);
            if (!pedRestoreVisibility) {
                SetEntityVisible(playerPed, false, false);
            }
        }
        FreezeEntityPosition(veh, false);
    } else {
        if (pedRestoreVisibility) {
            NetworkFadeInEntity(playerPed, true);
        }
        FreezeEntityPosition(playerPed, false);
    }

    DoScreenFadeIn(500);
    SetGameplayCamRelativePitch(0.0, 1.0);
}

export async function teleportToWaypoint(): Promise<void> {
    const pos = getWaypointPosition();
    if (pos === null) {
        log('You need to set a waypoint first!');
        return;
    }

    await teleportToCoords(pos);
}

Evidence :
https://streamable.com/43lnbo

Expected Behavior

Teleportation to the desired location inside the vehicle as the driver

Actual Behavior

A somewhat haphazard teleportation that occasionally takes place outside the vehicle

Evidence

No response

Additional Context

No response

[Gogsi]

A fix for this bug has been implemented and is available in August 11 Patch. Please try again and let us know if the issue persists. Thanks for your help!

[i20h]

I'm currently on vacation. I'll get back to you in 48 hours.

[i20h]

Look fine