That sounds like Cheat Engine to me.

If you spent the same amount of effort into the description and presentation of your uploads as the opening post, they probably would've been approved by now.

The moderation team does this in their free time. There are only a handful of moderators. When there are many pending uploads to be approved or rejected, it can take some time before the latest uploads are processed. Hence the 24 hours - it gives everybody the time to look at things.

The author has taken it down, an update was in development some time ago.

Ask the author

@InfamousSabre

Mirrors in vehicles can not reflect other objects, only the world. You should see streets and stuff.

Depending on the vehicle you're driving in, the mirror "quality" can be high, very low or entirely missing. You should tell the vehicle author about this.

If it's a system you built, you might want to make sure it's stable first before trying stuff.

This is general PC (building) advice though. What are the specs of the system you put together?

1. Make sure your power supply is powerful enough to power the system
2. Make sure the CPU cooler is mounted properly and not too much/not too little thermal paste/goo is used.
3. Make sure your RAM isn't faulty, run memtest86 or something to check for RAM stability.

First you need to get GTA V to run on Linux. I suppose you use Steams' Proton? If that works, it's worth a try just installing mods normally and see how things end up.

Read the description - they're from the Project Homecoming FiveM server. (I believe it is/was run by the VanillaWorks guys)

Update ScriptHookV.

Visual Studio is a programming program. You're looking for 3D modeling programs.

Can't help ya there, I only know how to code.

@Biggdogg
That link itself is suspicious lmao

It's 2.10.13 now. Should still be compatible with 2.10 though.

Check if the native implementation changed - don't think it has, but better to be sure.

Launch control:

The explody anti-lag stuff is in TurboFix. I probably have to expand the TurboFix API to allow enabling/disabling the anti-lag to make it controllable from Manual Transmission, or I could cheap out with simple keybinds. We'll see.

Probably this one?

https://www.gta5-mods.com/scripts/nfsgauge-rpm-gear-speedometer

Handling Replacement

Info

A library/tool for script developers, to manage vehicle handling changes in non-intrusive way. It clones the handling of a vehicle, and assign the copy to the vehicle, so only that vehicle is affected by changes to its handling data.

This comes in handy for scripts that want to continuously vary certain parameters, without affecting other instances of that vehicle model.

An example is my variable drive bias, which changes fDriveBiasFront constantly:

Usage

The header as of now:

#pragma once

#ifdef HR_EXPORTS
#define HR_API extern "C" __declspec(dllexport)

#define STR_HELPER(x) #x
#define STR(x) STR_HELPER(x)

#define VER_MAJOR 1
#define VER_MINOR 0
#define VER_PATCH 0

#define HR_VER STR(VER_MAJOR) "."  STR(VER_MINOR) "." STR(VER_PATCH)
#else
#ifndef HR_RUNTIME
#define HR_API extern "C" __declspec(dllimport)
#else
// noop
#define HR_API
#endif
#endif

/**
 * \brief   Enables the replacement handling on the vehicle. Increments reference count if \p vehicle already has a
 *          replaced handling.
 *
 * \param [in] vehicle              Vehicle to enable the replacement handling on.
 * \param [out] ppHandlingData      Pointer to replaced handling pointer.\n
 *                                  nullptr when \p vehicle doesn't exist.
 * \return                          true    if this HR_Enable call replaced the handling.\n
 *                                  false   if the handling already has been replaced, or\n
 *                                          if \p ppHandlingData is nullptr, or\n
 *                                          if \p vehicle doesn't exist.
 */
HR_API bool HR_Enable(int vehicle, void** ppHandlingData);

/**
 * \brief   Decrements reference count on \p vehicle. Disables the replacement handling on the vehicle when
 *          the reference count has reached 0.
 *
 * \param [in] vehicle              Vehicle to restore handling on.
 * \param [out] ppHandlingData      Pointer to current handling pointer after deletion.\n
 *                                  nullptr when \p vehicle doesn't exist.
 * \return                          true    if this HR_Enable call restored the original handling.\n
 *                                  false   if the handling was not restored by this call, or\n
 *                                          if \p vehicle didn't have a replaced handling, or\n
 *                                          if \p ppHandlingData is nullptr, or\n
 *                                          if \p vehicle doesn't exist.
 */
HR_API bool HR_Disable(int vehicle, void** ppHandlingData);

/**
 * \brief   Get the current handling data
 *
 * \param [in] vehicle                      Vehicle to get handling from.
 * \param [out] ppHandlingDataOriginal      Pointer to the original handling.\n
 *                                          nullptr if \p vehicle doesn't exist.\n
 *                                          <b>DO NOT WRITE TO THIS!</b>
 * \param [out] ppHandlingDataReplaced      Pointer to the replaced handling.\n
 *                                          nullptr if \p vehicle doesn't exist or no replaced handling.
 * \return                                  true    if the handling has been replaced.\n
 *                                          false   if the handling is original, or\n
 *                                                  if either \p ppHandlingDataOriginal / \p ppHandlingDataReplaced
 *                                                  is null, or
 *                                                  if \p vehicle doesn't exist.\n
 */
HR_API bool HR_GetHandlingData(int vehicle, void** ppHandlingDataOriginal, void** ppHandlingDataReplaced);

Currently general usage:

    void* handlingDataOrig = nullptr;
    void* handlingDataReplace = nullptr;
    
    if (!HR_GetHandlingData(g_playerVehicle, &handlingDataOrig, &handlingDataReplace)) {
        HR_Enable(g_playerVehicle, &handlingDataReplace);
        return;
    }
    // after this you can read or write stuff, e.g.
    *(float*)((uint8_t*)handlingDataReplace + fInitialDriveForceOffset) = 1.0f;

CHandlingData is left to the user. The library only clones CHandlingData and CBaseSubHandlingData and doesn't mess around or limit the user further. Thus, void** is used to pass CHandlingData* around.

Credits

FiveM: Couldn't get CBaseSubHandlingData to work without some help

Download

GTA5-Mods

Might be interesting to throw a script at it and create secondary damage/explosion orbs like the original BFG 9000 or damaging in the area around the projectile before reaching its point (like in 2016/Eternal).

Useful info video:

fInitialDriveMaxFlatVel is most definitely purely coupled to engine/gear-defined speeds.

In handling data, there's a field that is 1.2 times fInitialDriveMaxFlatVel. Let's call it fDriveMaxFlatVel for now. (It's converted to meters per second in the handling data, by the way)

If you take this speed and divide it by gear ratio, you get the speed at which the engine RPM is max (1.0). This works for any gear. The top gear in GTA V usually has a ratio of 0.9. If we define "top speed" as "speed in top gear, with RPM maxed out", you'd indeed get float topSpeed = (fInitialDriveMaxFlatVel * 1.2) / 0.9 - or float topSpeed = fInitialDriveMaxFlatVel * 1.33...

Changing the nInitialDriveGears doesn't impact top speed(1), neither does the Gearbox tuning option.

(1): The look-up table (or calculation) has a bug where the 7th gear and up, have a higher gear ratio (thus lower speed range for that gear). Affects both if you set number of gears in nInitialDriveGears or have a 6-speed gearbox and use the Gearbox tuning option.

Now you ask, "Why does it throw in a 1.2 factor?"
I have no idea.

Also, semi-related fun fact - the speeds always are purely defined by gear ratio and fDriveMaxFlatVel. Changing wheel/tyre radius has no impact on speeds, nor does RPM change, and acceleration (torque or horsepower) also does not seem to be affected. Oh, Rockstar...

ScriptHookVDotNet.log shows what script crashed.

Yeet an object and check its trajectory. If there's no resistance the forward speed should stay constant.

I don't think the game fully simulates drag (and certainly doesn't model for what face is facing forward), but from my own observations, forward and downward speed does decrease to a constant-ish value for falling cars.

Sorry, my hands are full for the moment.

Seems like @AHK1221 and @sollaholla were involved with the coding stuff, so they might have the original code. Otherwise your best bet would be to ask the authors for the source code and update it somehow.

@04edwakei
Yeah it's got controller support.

Right - it wasn't immediately clear that OP meant a Tool/dev resource upload.

Users should always have something representative of the final result.

If you can not put it ingame yourself, users also might have trouble with it.

@dodgeboy121 just look at the lines, they intersect at the com

@dodgeboy121
Open it in OpenIV.