Jump to content
Sign in to follow this  
Reptilienski

[SLOVED]Amphibious Vehicle on water speed issue?

Recommended Posts

Got an Amphibious Vehicle that tried to make, already made is moving on land and water.

The on land speed works all good, but the on water speed is too low, no matter how I setting the vehicles speed the on water speed seem capped at 30km/s.

I tried set waterspeedcoef and maxSpeed to a higher value, but the on water speed of the vehicle do not changed and kept at 30km/s.

Which attribute would affect the vehicle on water speed? and is it possible to make the on water speed higher than 30km/s? 

Share this post


Link to post
Share on other sites

yes that possible i use this params for my schwimmwagen and reduce a speed to 10km in water in the config cpp class CfgVehicles.

 

 


                canfloat = true;
                engineEffectSpeed = 5;
                waterFastEffectSpeed = 8;
                waterspeedcoef = 0.2;
                waterSpeedFactor = 2;
                waterResistanceCoef = 0.09;
                waterResistance = 1;/// if the depth of water is bigger than maxFordingDepth it starts to damage the engine after this time

               maxFordingDepth         = 0.5;            /// how high water would damage the engine of the car

 

Share this post


Link to post
Share on other sites
On 8/20/2021 at 1:02 AM, cervantes said:

yes that possible i use this params for my schwimmwagen and reduce a speed to 10km in water in the config cpp class CfgVehicles.

 

 


                canfloat = true;
                engineEffectSpeed = 5;
                waterFastEffectSpeed = 8;
                waterspeedcoef = 0.2;
                waterSpeedFactor = 2;
                waterResistanceCoef = 0.09;
                waterResistance = 1;/// if the depth of water is bigger than maxFordingDepth it starts to damage the engine after this time

               maxFordingDepth         = 0.5;            /// how high water would damage the engine of the car

 

so basicly I just need to take down the value of  waterResistance and maxFordingDepth the water speed would go up? like waterResistance = 0.09 and maxFordingDepth         = 0.1?

Share this post


Link to post
Share on other sites
19 minutes ago, cervantes said:

yes 🙂

Thx, gonna try this after work, really there's no such thing about water speed for Amphibious Vehicle on BIS wiki, which makes it a lot of harder for me to understand it.

Share this post


Link to post
Share on other sites

yes understanding the arma3 physx engine its not eazy 😉

Share this post


Link to post
Share on other sites

Hi....

 

One question regarding Water speed in amphibious vehicles.

Is there a way for a land (amphibious) vehicle so it can move faster in water than in land???

I remember making that in arma 2 with simulation=car

 

But it doesn't work with class Carx

Share this post


Link to post
Share on other sites
15 hours ago, mankyle said:

Hi....

 

One question regarding Water speed in amphibious vehicles.

Is there a way for a land (amphibious) vehicle so it can move faster in water than in land???

I remember making that in arma 2 with simulation=car

 

But it doesn't work with class Carx

So simulation = car no longer works in Arma3 right?

 

Share this post


Link to post
Share on other sites

none of these value changes anything for the warter speed, it just simple not work, I attached my config below, don't know where is gose wrong, maybe you may have a look and find some thing

 

Share this post


Link to post
Share on other sites

more im not sure but equal speed yes 🙂

 

you can add 0 into value for no water resistance and script the velocity of vehicle when he are in water 😉

 

 

Share this post


Link to post
Share on other sites
On 8/26/2021 at 1:44 AM, cervantes said:

more im not sure but equal speed yes 🙂

 

you can add 0 into value for no water resistance and script the velocity of vehicle when he are in water 😉

 

 

turned out, all these setting would not have effect, unless you have define a amphibious gearbox for the vehicle, I added one and now all works.

  • Like 1

Share this post


Link to post
Share on other sites

Amphibious gearbox??

 

Could you expand that???

 

What do you hace to define for an amphibious gearbox??

Share this post


Link to post
Share on other sites

hi Mankyle this are not really hard for working physx vehicle on arma3.

 

the most important lod for working a amphibious vehicle is a buoyancy lod 🙂

 

i d'ont modifiate a gearbox params from my schwimmwagen i use only a cpp waters values for simulating that 🙂

 

and do not required to modifiate a gearbox 🙂

 

for a boyancy and physx lod is just really important all faces its closed and convex but not required for a geometry lod 😉

 

of course the size of boyancy lod meshs affect also a moves in water 🙂

 

one movie for you can see that 🙂

 

https://www.youtube.com/watch?v=za-MMB26-qc

 

note also a properties in geo lod reversed = 1; and buoyancy = 1 and d'ont add autocenter 😉

and the config 🙂

 

Spoiler

#define TEast 0
#define TWest 1
#define TGuerrila 2
#define TCivilian 3
#define TSideUnknown 4
#define TEnemy 5
#define TFriendly 6
#define TLogic 7

#define true 1
#define false 0

// type scope
#define private 0
#define protected 1
#define public 2

#define LockNo         0
#define LockCadet         1
#define LockYes         2

#define mag_xx(a,b) class _xx_##a {magazine = a; count = b;}
#define weap_xx(a,b) class _xx_##a {weapon = a; count = b;}
#define item_xx(a,b) class _xx_##a {name = a; count = b;}
#define bag_xx(a,b) class _xx_##a {backpack = a; count = b;}

#define DEFAULT_SLOT 0
#define MUZZLE_SLOT 101
#define OPTICS_SLOT 201
#define FLASHLIGHT_SLOT 301
#define NVG_SLOT 602
#define GOGGLE_SLOT 603
#define HEADGEAR_SLOT 605
#define UNIFORM_SLOT 801

#define HMD_SLOT       616
#define BINOCULAR_SLOT 617
#define MEDIKIT_SLOT   619
#define RADIO_SLOT    611

#define VEST_SLOT      701
#define BACKPACK_SLOT  901

#define CanSeeRadar 1
#define CanSeeEye 2
#define CanSeeOptics 4
#define CanSeeEar 8
#define CanSeeCompass 16
#define CanSeeAll 31
#define CanSeePeripheral 32
#define CanSeeRadarC CanSeeRadar+CanSeeCompass
class DefaultEventhandlers;


class CfgPatches
{
     class schwimmwagen
         {
            units[] = {"schwimmwagen"};
            weapons[] = {};
                        requiredAddons[]={};
            requiredVersion = 1.0;
                        author = "Morenon Samy";
         };
};
//-----------------------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------
class CfgVehicleClasses
{
    class Farmland
    {
    displayName = "Farmland";
    };
};
//-----------------------------------------------------------------------------------------------------------------------------
class CfgFactionClasses {
    class NO_CATEGORY;
    class schwimmwagen {
    displayName = "schwimmwagen";
    priority = 100;
        icon = "\Woodlander\trap_ico.paa";
    side = 3;
     };
};
//-----------------------------------------------------------------------------------------------------------------------------
class CfgSounds
{
    class blow_out
    {
        name = "blow_out"; // Name for mission editor
        sound[] = {"\schwimmwagen\sounds\blow_out.wav", +10, 1.0,10};
        titles[] = {0, ""};
    };

 };

//-----------------------------------------------------------------------------------------------------------------------------
class CfgVehicles
{
    class house;
    class Car;

    class schwimmwagen_repair_pos: house
    {
        icon = "";
        displayname = "repair pos"
        scope = 1;
        destrType=DestructMan;
        vehicleClass = "Farmland";
        reversed=false;
        model="\schwimmwagen\repairpos.p3d";

    };

    class Car_F: Car
    {
                armorStructural= 4;    // ranges between 1 and 4.0, default 1
                armorFuel = 1.4;    // default
                armorGlass = 0.5;    // default
                armorLights = 0.4;    // default 0.4 in all models.
                armorWheels = 0.05
        armor = 32;
                type = 0;
                unitInfoType = "RscUnitInfo";
                curatorInfoType = "RscDisplayAttributesVehicle";
                hideUnitInfo = false;
                selectionBackLights = "lightsback";
                selectionBrakeLights = "lightsbrake";

                class AnimationSources
                {
                       class hidewheel
                       {
                        selection = "spare_wheel";
                       initPhase = 0.0;
                       animPeriod = 0;
               };
                };

        class HitPoints /// we want to use hitpoints predefined for all cars
        {
            class HitLFWheel;
            class HitLF2Wheel;
            class HitRFWheel;
            class HitRF2Wheel;
            class HitBody;
            class HitGlass1;
            class HitGlass2;
            class HitGlass3;
            class HitGlass4;
            class HitGlass5;
            class HitGlass6;
        };
        class EventHandlers;
    };

    class schwimmwagen: Car_F
    {
        vehicleClass="Farmland";
        faction = "schwimmwagen";
        model     = "\schwimmwagen\schwimmwagen";  /// simple path to model
        picture    = "\schwimmwagen\picture.paa"; /// just some icon in command bar
        Icon    = "\schwimmwagen\icon.paa"; /// icon in map
        scope = 2;
                type = 0;
                forceInGarage = true;
        scopeGarage = 2;
                scopeArsenal=2;

                canfloat = true;
                engineEffectSpeed = 5;
                waterFastEffectSpeed = 8;
                waterspeedcoef = 0.2;
                waterSpeedFactor = 2;
                waterResistanceCoef = 0.09;
                waterResistance = 1;/// if the depth of water is bigger than maxFordingDepth it starts to damage the engine after this time
                memoryPointsLeftWaterEffect = "propeller_fx";

        side=3;
        rarityUrban = -1;
                preferRoads = false; 
                unitInfoType = "RscUnitInfoNoWeapon";
                curatorInfoType = "RscDisplayAttributesVehicle";
                hideUnitInfo = false;
        displayName = "schwimmwagen"; /// displayed in Editor
        hiddenSelections[] = {}; ///we want to allow changing the color of this selection

        terrainCoef     = 1.3;     /// different surface affects this car more, stick to tarmac
        turnCoef         = 2.5;     /// should match the wheel turn radius
        precision         = 10;     /// how much freedom has the AI for its internal waypoints - lower number means more precise but slower approach to way
        brakeDistance     = 3.0;     /// how many internal waypoints should the AI plan braking in advance
        acceleration     = 15;     /// how fast acceleration does the AI think the car has


        fireResistance     = 5;     /// lesser protection against fire than tanks
                armorStructural= 4;    // ranges between 1 and 4.0, default 1
                armorFuel = 1.4;    // default
                armorGlass = 0.5;    // default
                armorLights = 0.4;    // default 0.4 in all models.
                armorWheels = 0.02;
        armor             = 32;     /// just some protection against missiles, collisions and explosions
        cost            = 50000; /// how likely is the enemy going to target this vehicle

        transportMaxBackpacks     = 3; /// just some backpacks fit the trunk by default
        transportSoldier         = 3; /// number of cargo except driver

        /// some values from parent class to show how to set them up
        wheelDamageRadiusCoef     = 0.9;             /// for precision tweaking of damaged wheel size
        wheelDestroyRadiusCoef     = 0.4;            /// for tweaking of rims size to fit ground
        maxFordingDepth         = 0.5;            /// how high water would damage the engine of the car
        crewCrashProtection        = 0.25;            /// multiplier of damage to crew of the vehicle => low number means better protection
        driverLeftHandAnimName     = "drivewheel"; /// according to what bone in model of car does hand move
        driverRightHandAnimName = "drivewheel";    /// beware, non-existent bones may cause game crashes (even if the bones are hidden during play)
                memoryPointExhaust = "exhaust";
                memoryPointExhaustDir = "exhaust_dir";
        class TransportItems /// some first aid kits in trunk according to safety regulations
        {
            item_xx(FirstAidKit,4);
        };

        class Exhausts
        {
            class Exhaust1 
            {
                position     = "exhaust";          
                direction     = "exhaust_dir";    
                effect         = "ExhaustsEffectBig";
            };

            class Exhaust2
            {
                position     = "exhaust2";
                direction     = "exhaust2_dir";
                effect         = "ExhaustsEffectBig";
            };
        };
        class Turrets{}; /// doesn't have any gunner nor commander
        class HitPoints: HitPoints
        {
            class HitLFWheel: HitLFWheel
            {
                radius=0.2;
                visual="wheel_1_1_hide";
                armorComponent="wheel_1_1_hide";
                        name = "wheel_1_1_steering";
                armor=-30;
                minimalHit=0;
                explosionShielding=4;
                passThrough=0;
            };
            class HitLF2Wheel: HitLF2Wheel
            {
                radius=0.2;
                visual="wheel_1_2_hide";
                armorComponent="wheel_1_2_hide";
                        name = "wheel_1_2_steering";
                armor=-30;
                minimalHit=0;
                explosionShielding=4;
                passThrough=0;
            };
            class HitRFWheel: HitRFWheel
            {
                radius=0.2;
                visual="wheel_2_1_hide";
                armorComponent="wheel_2_1_hide";
                        name = "wheel_2_1_steering";
                armor=-30;
                minimalHit=0;
                explosionShielding=4;
                passThrough=0;
            };
            class HitRF2Wheel: HitRF2Wheel
            {
                radius=0.2;
                visual="wheel_2_2_hide";
                armorComponent="wheel_2_2_hide";
                        name = "wheel_2_2_steering";
                armor=-30;
                minimalHit=0;
                explosionShielding=4;
                passThrough=0;
            };

            class spare_Wheel: HitLFWheel
            {
                radius=0.2;
                visual="spare_Wheel";
                armorComponent="spare_Wheel";
                        name = "spare_Wheel";
                armor=-30;
                minimalHit=0;
                explosionShielding=4;
                passThrough=0;
            };

            class HitFuel             {armor=0.50; material=-1; name="palivo"; visual=""; passThrough=0.2;}; /// correct points for fuel tank, some of the damage is aFRLied to the whole
            class HitEngine         {armor=0.50; material=-1; name="engine"; visual=""; passThrough=0.2;};
            class HitBody: HitBody     {name = "body"; visual="camo1"; passThrough=0;}; /// all damage to the hull is aFRLied to total damage
            class HitGlass1: HitGlass1 {armor=0.25; name="glass1";}; /// it is pretty easy to puncture the glass but not so easy to remove it

        };

        driverAction         = driver_offroad01; /// what action is going the driver take inside the vehicle. Non-existent action makes the vehicle inaccessible
        cargoAction[]         = {passenger_low01, passenger_generic01_leanleft, passenger_generic01_foldhands}; /// the same of all the crew
        getInAction         = GetInLow;         /// how does driver look while getting in
        getOutAction         = GetOutLow;         /// and out
        cargoGetInAction[]     = {"GetInLow"};     /// and the same for the rest, if the array has fewer members than the count of crew, the last one is used for the rest
        cargoGetOutAction[] = {"GetOutLow"};     /// that means all use the same in this case

        #include "sounds.hpp"    /// sounds are in a separate file to make this one simple
        //#include "pip.hpp"        /// PiPs are in a separate file to make this one simple
        #include "physx.hpp"    /// PhysX settings are in a separate file to make this one simple

        class PlayerSteeringCoefficients /// steering sensitivity configuration
        {
             turnIncreaseConst     = 0.3; // basic sensitivity value, higher value = faster steering
             turnIncreaseLinear = 1.0; // higher value means less sensitive steering in higher speed, more sensitive in lower speeds
             turnIncreaseTime     = 1.0; // higher value means smoother steering around the center and more sensitive when the actual steering angle gets closer to the max. steering angle

             turnDecreaseConst     = 5.0; // basic caster effect value, higher value = the faster the wheels align in the direction of travel
             turnDecreaseLinear = 3.0; // higher value means faster wheel re-centering in higher speed, slower in lower speeds
             turnDecreaseTime     = 0.0; // higher value means stronger caster effect at the max. steering angle and weaker once the wheels are closer to centered position

             maxTurnHundred     = 0.7; // coefficient of the maximum turning angle @ 100km/h; limit goes linearly to the default max. turn. angle @ 0km/h
        };

        /// memory points where do tracks of the wheel appear
        // front left track, left offset
        memoryPointTrackFLL = "TrackFLL";
        // front left track, right offset
        memoryPointTrackFLR = "TrackFLR";
        // back left track, left offset
        memoryPointTrackBLL = "TrackBLL";
        // back left track, right offset
        memoryPointTrackBLR = "TrackBLR";
        // front right track, left offset
        memoryPointTrackFRL = "TrackFRL";
        // front right track, right offset
        memoryPointTrackFRR = "TrackFRR";
        // back right track, left offset
        memoryPointTrackBRL = "TrackBRL";
        // back right track, right offset
        memoryPointTrackBRR = "TrackBRR";
//-----------------------------------------------------------------------------------------
        class Damage /// damage changes material in specific places (visual in hitPoint)
        {
            tex[]={};
            mat[]=
            {
                "A3\data_f\glass_veh_int.rvmat",         /// material mapped in model
                "A3\data_f\Glass_veh_damage.rvmat",     /// changes to this one once damage of the part reaches 0.5
                "A3\data_f\Glass_veh_damage.rvmat",        /// changes to this one once damage of the part reaches 1

                "A3\data_f\glass_veh.rvmat",            /// another material
                "A3\data_f\Glass_veh_damage.rvmat",        /// changes into different ones
                "A3\data_f\Glass_veh_damage.rvmat"
            };
        };

                       class AnimationSources:AnimationSources
                       {
                       class hidewheel
                       {
                        selection = "spare_wheel";
                       initPhase = 0.0;
                       animPeriod = 0;
               };
                };
//-----------------------------------------------------------------------------------------
        class Reflectors    /// only front lights are considered to be reflectors to save CPU
        {
            class LightCarHeadL01     /// lights on each side consist of two bulbs with different flares
            {
                color[]         = {1900, 1800, 1700};        /// approximate colour of standard lights
                ambient[]        = {5, 5, 5};                /// nearly a white one
                position         = "LightCarHeadL01";        /// memory point for start of the light and flare
                direction         = "LightCarHeadL01_end";    /// memory point for the light direction
                hitpoint         = "Light_L";                /// point(s) in hitpoint lod for the light (hitPoints are created by engine)
                selection         = "Light_L";                /// selection for artificial glow around the bulb, not much used any more
                size             = 1;                        /// size of the light point seen from distance
                innerAngle         = 100;                        /// angle of full light
                outerAngle         = 179;                        /// angle of some light
                coneFadeCoef     = 10;                        /// attenuation of light between the above angles
                intensity         = 1;                        /// strength of the light
                useFlare         = true;                        /// does the light use flare?
                dayLight         = false;                    /// switching light off during day saves CPU a lot
                flareSize         = 1.0;                        /// how big is the flare

                class Attenuation
                {
                    start             = 1.0;
                    constant         = 0;
                    linear             = 0;
                    quadratic         = 0.25;
                    hardLimitStart     = 30;        /// it is good to have some limit otherwise the light would shine to infinite distance
                    hardLimitEnd     = 60;        /// this allows adding more lights into scene
                };
            };
//-----------------------------------------------------------------------------------------
            class LightCarHeadR01: LightCarHeadL01
            {
                position     = "LightCarHeadR01";
                direction     = "LightCarHeadR01_end";
                hitpoint     = "Light_R";
                selection     = "Light_R";
            };

        };

        aggregateReflectors[] = {{"LightCarHeadL01"}, {"LightCarHeadR01"}};
//-----------------------------------------------------------------------------------------
  class UserActions
  {
   class repair1
   {
    onlyforplayer = 1;
    displayName = "Repair wheel";
    position = "wheel_1_1_axis";
    radius = 1.5;
    condition = "this getHit ""wheel_1_1_steering"" >= 1;";
    statement = "[this,player,""wheel_1_1_steering""] exec ""\schwimmwagen\scripts\repair.sqs""";
   };
   class repair2
   {
    onlyforplayer = 1;
    displayName = "Repair wheel";
    position = "wheel_1_2_axis";
    radius = 1.5;
    condition = "this getHit ""wheel_1_2_steering"" >= 1;";
    statement = "[this,player,""wheel_1_2_steering""] exec ""\schwimmwagen\scripts\repair.sqs""";
   };
   class repair3
   {
    onlyforplayer = 1;
    displayName = "Repair wheel";
    position = "wheel_2_1_axis";
    radius = 1.5;
    condition = "this getHit ""wheel_2_1_steering"" >= 1;";
    statement = "[this,player,""wheel_2_1_steering""] exec ""\schwimmwagen\scripts\repair.sqs""";
   };
   class repair4
   {
    onlyforplayer = 1;
    displayName = "Repair wheel";
    position = "wheel_2_2_axis";
    radius = 1.5;
    condition = "this getHit ""wheel_2_2_steering"" >= 1;";
    statement = "[this,player,""wheel_2_2_steering""] exec ""\schwimmwagen\scripts\repair.sqs""";
   };
  };
//-----------------------------------------------------------------------------------------

        class EventHandlers: EventHandlers
        {
            init="[_this select 0] exec ""\schwimmwagen\scripts\init.sqs"";";
        };

        // Must be kept as fail-safe in case of issue with the function
        hiddenSelectionsTextures[]={"\A3\Weapons_F\Data\placeholder_co.paa"};     /// we could use any texture to cover the car
        

        };
    };
};
 

 

Share this post


Link to post
Share on other sites
14 hours ago, mankyle said:

Amphibious gearbox??

 

Could you expand that???

 

What do you hace to define for an amphibious gearbox??

class complexGearbox
		{
			GearboxRatios[] = {"R1",-4.84,"N",0,"D1",3.43,"D2",2.01,"D3",1.42,"D4",1,"D5",0.83,"D6",0.59};
			TransmissionRatios[] = {"High",8};
			AmphibiousRatios[] = {"R1",-4.84,"N",0,"D1",3.43,"D2",2.01,"D3",1.42,"D4",1,"D5",0.83,"D6",0.59};
			gearBoxMode = "auto";
			moveOffGear = 1;
			driveString = "D";
			neutralString = "N";
			reverseString = "R";
		};

this is the only thing I changed in complexGearbox, I just make the AmphibiousRatios all the same with GearboxRatios, and then all the waterspeedcoef, waterSpeedFactor, waterResistanceCoef, etc, they just works after I did that. Before I dont have a AmphibiousRatios that was not same with GearboxRatios, and with that all the changes in waterspeedcoef, waterSpeedFactor, waterResistanceCoef, etc, do not works, only after I give the boat a right AmphibiousRatios value it works.

Share this post


Link to post
Share on other sites

i not known why my last post is hidden and try again ^^

 

i use that gearbox config

 

Spoiler

     thrustDelay                = 0.2;         /// initial delay to cause lesser slip when on 1st gear - thrust goes from zero to full in this time
        brakeIdleSpeed             = 1.78;     /// under what speed (in m/s) does the brake apply for a vehicle without thrust
        maxSpeed                   = 91;         /// vehicle can go a bit over, but dramatically decreases thrust
        fuelCapacity               = 45;
        wheelCircumference         = 2.277;     /// diameter of 725

        antiRollbarForceCoef    = 0;     /// how strong is the anti-roll bar of vehicle preventing it to lose grip in turns (not any magical stuff, real ARB)
        antiRollbarForceLimit    = 0.5;     /// highest possible force of ARB
        antiRollbarSpeedMin     = 10;     /// the roll bar force gets from zero to full in range of min and max speed
        antiRollbarSpeedMax        = 80;      /// this simulates losing grip at high speed turns

        /// Gearbox and transmission  via PhysX
        idleRpm = 900; // RPM at which the engine idles.
        redRpm = 6900; // RPM at which the engine redlines.

        class complexGearbox
        {
            GearboxRatios[]    = {"R1",-3.231,"N",0,"D1",2.462,"D2",1.870,"D3",1.241,"D4",0.970,"D5",0.711};
            TransmissionRatios[] = {"High",4.111}; // Optional: defines transmission ratios (for example, High and Low range as commonly found in offroad vehicles)
            gearBoxMode        = "auto"; //gearbox can be of type: full-auto (only requires 'W' or 'S'), auto (requires shift between drive and reverse), semi-auto, manual
            moveOffGear        = 1; // defines what gear an automatic or semi-automatic gearbox will move off from stationary in. 1 by default.
            driveString        = "D"; // string to display in the HUD for forward gears.
            neutralString      = "N"; // string to display in the HUD for neutral gear.
            reverseString      = "R"; // string to display in the HUD for reverse gears.


        };

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// PhysX parameters
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // <Description>: Defines simulation type of the vehicle. PhysX simulation ends with letter "x", "carx", "tankx" ...
        // <Type>: string
        // <Default>: (required)
        simulation = "carx";

        // <Description>: Defines how much dampers react to random little bumps on surface. It's only visual effect, doesn't influence drive simulation,
        // only taken into account when calculating damper animation.
        // <Type>: float
        // <Default>: 0.0
        dampersBumpCoef = 0.05;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Differential parameters
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // <Description>: A number of differential types are supported: 4-wheel drive with open differential, 4-wheel drive with limited slip, front-wheel drive
        // with open differential, front-wheel drive with limited slip, rear-wheel drive with open differential, rear-wheel drive with limited slip.
        // <Type>: string; acceptable values: "all_open", "all_limited", "front_open", "front_limited", "rear_open", "rear_limited"
        // <Default>: "all_limited"
        differentialType = "front_limited";

        // <Description>: Ratio of engine power that goes to front wheels out of total power for 4-wheel drive differentials.
        // Choosing a value greater than 0.5 delivers more torque to the front wheels, while choosing a value less than 0.5
        // delivers more torque to the rear wheels. This value is ignored for front-wheel drive and rear-wheel drive differentials.
        // <Type>: float
        // <Default>: 0.5
        frontRearSplit = 0.5;

        // <Description>: This is the largest possible relative difference between speed of front wheels. It helps to have outside wheels a bit faster
        // during the turns, but it prevents the faster wheel to take all the power while sliding. The power is shifted to slower wheel once the value is reached.
        // Locked differential has value of 1, the softer is the lock the greater should the value be.
        // This value is ignored except for front-wheel drive or four wheel drive with limited slip.
        // A good starting value is around 1.3.
        // <Type>:
        // <Default>:
        frontBias = 1.5;

        // <Description>: This is similar to frontBias except that it refers to the rear wheels.
        // This value is ignored except for rear-wheel drive or four wheel drive with limited slip.
        // A good starting value is around 1.3.
        // <Type>: float
        // <Default>: 1.3
        rearBias = 1.3;

        // <Description>: This value is similar to the frontBias and rearBias, except that it refers to the sum of the front wheel rotation speeds and the sum
        // of the rear wheel rotation speeds.
        // This value is ignored except for four wheel drive with limited slip.
        // A good starting value is around 1.3.
        // <Type>: float
        // <Default>: 1.3
        centreBias = 1.3;

        // <Description>: How fast is engine power distributed to the wheels. Stronger values mean more aggressive drive performance inclining to
        // slip a little while changing gears while weaker values are better for comfortable seamless ride.
        // <Type>: float
        // <Default>: 10.0
        clutchStrength = 15.0;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Engine parameters
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // <Description>: Power of the engine in kW.
        // <Type>: float
        // <Default>: (required)
        enginePower = 100;


        // <Description>: This is the maximum rotational speed of the engine expressed in radians per second. It could be calculated from maximum
        // engine RPM like this:
        // maxOmega = (maxRpm*2*Pi)/60.
        // <Type>: float
        // <Default>: 600 which is cca 6000 rounds per minute.
        maxOmega = 720;

        // <Description>: This is the maximum torque that is ever available from the engine. This is expressed in Newton metres.
        // <Type>: float
        // <Default>: value calculated from enginePower according to http://en.wikipedia.org/wiki/Horsepower#Relationship_with_torque
        peakTorque = 350;

        // <Description>: These three values describe internal damping of the engine. Bigger values mean greater damping. Clutch disengaged value
        // is used while shifting gears, engine interpolates between clutch engaged and full throttle values according to throttle input.
        // We tend to use slightly lower clutch engaged values because it allows cars to turn more smoothly.
        // Typical values in range (0.25,3). The simulation can become unstable with damping rates of 0.
        // <Type>: float, float, float
        // <Default>: 0.08, 2.0, 0.35
        dampingRateFullThrottle = 0.08;
        dampingRateZeroThrottleClutchEngaged = 0.35;
        dampingRateZeroThrottleClutchDisengaged = 0.35;

        // <Description>: This is a graph of peak torque versus engine rotational speed.
        // The x-axis of the curve is the relative engine speed; that is, the engine speed divided by the maximum engine speed. The y-axis of the curve is a
        // multiplier in range (0,1) that is used to scale the peak torque. It is good to keep the values in mind while setting changeGearMinEffectivity.
        // <Type>: Array[2] where i = number of samples, maximum 8;
        // <Default>: {{0.0, 0.8}, {0.33, 1.0}, {1.0, 0.8}}
        torqueCurve[] = {{0.000, 0.000}, {0.178, 0.800}, {0.250, 1.0}, {0.461, 0.900}, {0.900, 0.800}, {1.000, 0.300}};

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Gearbox parameters
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // <Description>: Value of minimal gear effectivity to hold current gear. If there is better gear and effectivity is below this value then change gear.
        // <Range>: (0,1)
        // <Type>: Array where i = number of gears
        // <Default>: 0.95 for every value (Neutral = 0.15 Not sure how important this is but we want to kick out of neutral very quickly)
        changeGearMinEffectivity[]   = {0.95, 0.15, 0.95, 0.95, 0.95, 0.95, 0.95};

        // <Description>: The switch time describes how long it takes (in seconds) for a gear change to be completed. This needs to be set to aggresive shifting
        // or it would cause issues while trying to run aggressively (mainly during evading the enemies).
        // <Type>: float
        // <Default>: 0.01
        switchTime = 0.31;

        // <Description>: Set the latency time of the gearbox, specified in s.
        // This is used to prevent instant shifting after changing gears - there is some power loss during gear change and it could seem that
        // previous gear is better for a brief time after shifting.
        // <Type>: float
        // <Default>: 2.0
        latency = 1.0;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Wheels parameters
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        class Wheels
        {
            class LF
            {
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // General parameters
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // <Description>: Name of the bone, used for wheel and suspension animations.
                // <Type>: string
                // <Default>: ""
                boneName = "wheel_1_1_damper";

                // <Description>: If true, wheel is steerable, false - wheel is fixed.
                // <Type>: bool
                // <Default>: (required)
                steering = true;

                // <Description>: Defines if wheel is on the right or left side of the vehicle
                // <Type>: string
                // <Default>: "right"
                side = "left";

                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Wheel PX parameters
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // <Description>: Center of the wheel (axis)
                // <Type>: memory point
                // <Default>: (required)
                center   = "wheel_1_1_axis";

                // <Description>: Point on the outside rim of the tire, used to calculate radius of the wheel (distance between center and boundary).
                // <Type>: memory point
                // <Default>: (required)
                boundary = "wheel_1_1_bound";

                // <Description>: This is the weight in kg of wheel including both rim and tyre.
                // <Type>: float
                // <Default>: 10.0
                mass = 20;

                // <Description>: This is the wheel's moment of inertia about the rolling axis. Smaller values result in more slips in aggresive driving
                // while larger hamper the gain of speed. Good base to start with is this formula:
                // MOI = 0.5 * Mass * Radius * Radius
                // Some tweaking is needed after the computation, but it is still better than nothing.
                // <Type>: float
                // <Default>: 0.5 * WheelMass * WheelRadius * WheelRadius
                MOI = 3.3;

                // <Description>:The damping rate describes the rate at which a freely spinning wheel loses rotational speed.
                // Values in range (0.25, 2) seem like sensible values. Experimentation is always a good idea, even outside this range.
                // <Type>: float
                // <Default>: 0.1
                dampingRate = 0.5;

                // <Description>: This is the value of the torque applied to the wheel when the brakes are maximally applied. Higher torques will lock the wheel
                // quicker when braking, while lower torques will take longer to lock the wheel.
                // A value of around 1500 is a good starting point for a vanilla wheel but a google search will reveal typical braking torques. One difficulty is
                // that these are often expressed by manufacturers as braking horsepower or in "pounds inches". The values required here are in "Newton metres".
                // <Type>: float
                // <Default>: 2500
                maxBrakeTorque = 2000;

                // <Description>: This is the same as the max brake torque except for the handbrake rather than the brake. Typically, for a 4-wheeled car,
                // the handbrake is stronger than the brake and is only applied to the rear wheels. A value of 4000 for the rear wheels is a good starting point,
                // while a value of 0 is necessary for the front wheels to make sure they do not react to the handbrake.
                // <Type>: float
                // <Default>: 2*maxBrakeTorque
                maxHandBrakeTorque = 0;

                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Wheel simulation parameters
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // <Description>: This is the direction of the suspension in the downward direction in the rest configuration of the vehicle. A vector that
                // points straight downwards is a good starting point.
                // <Type>: Array[3]
                // <Default>: {0, -1, 0}
                suspTravelDirection[] = {0, -1, 0};

                // <Description>: This is the application point of the suspension force.
                // <Type>: memory point
                // <Default>: center
                suspForceAppPointOffset = "wheel_1_1_axis";

                // <Description>: This is almost the same as the suspension force app point except for the lateral and longitudinal forces that develop on the tire.
                // A good starting point is to duplicate the suspension force application point.
                // <Type>: memory point
                // <Default>: suspForceAppPointOffset
                tireForceAppPointOffset = "wheel_1_1_axis";

                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Suspension parameters
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // <Description>: These values describe the maximum compression and elongation in metres that the spring can support.
                // <Type>: float
                // <Default>: 0.15
                maxCompression = 0.1;
                maxDroop = 0.15;

                // <Description>: This is the mass in kg that is supported by the suspension spring.
                // <Type>: float
                // <Default>: vehicleMass/numberOfWheels
                sprungMass = 350.0;

                // <Description>: This is the strength of the suspension spring in Newtons per metre.
                //   springStrength = naturalFrequency * naturalFrequency * sprungMass
                // <Type>: float
                // <Default>: sprungMass*5,0*5,0
                springStrength = 22600;

                // <Description>: This describes the rate at which the spring dissipates the energy stored in the spring.
                // Basic equiation for this is
                //  springDamperRate = dampingRatio * 2 * sqrt(springStrength * sprungMass)
                // where dampingRatio = 1 mean critical damping (critically damped pendulum should get back to start point in every swing)
                // <Type>: float
                // <Default>: 0,4*2*sqrt(springStrength*sprungMass)
                springDamperRate = 8680;

                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Tire parameters
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // <Description>: Increasing this value will result in the tire attempting to generate more longitudinal force when the tire is slipping.
                // Typically, increasing longitudinal stiffness will help the car accelerate and brake. The total tire force available is limited by the
                // load on the tire so be aware that increases in this value might have no effect or even come at the expense of reduced lateral force.
                // <Type>: float
                // <Default>: 10000
                longitudinalStiffnessPerUnitGravity = 100000;

                // <Description>: These values together describe the lateral stiffness per unit lateral slip (in radians) of the tire.
                // <Type>: float, float
                // <Default>: 25, 180
                latStiffX = 25;
                latStiffY = 18000;

                // <Description>: These six values describe a graph of friction as a function of longitudinal slip.
                // A good starting point for this is a flat graph of friction vs slip with these values:
                // frictionVsSlipGraph[0][0]=0.0
                // frictionVsSlipGraph[0][1]=1.0
                // frictionVsSlipGraph[1][0]=0.5
                // frictionVsSlipGraph[1][1]=1.0
                // frictionVsSlipGraph[2][0]=1.0
                // frictionVsSlipGraph[2][1]=1.0
                // <Type>: Array[3][2]
                // <Default>: {{0, 1}, {0.5, 1}, {1,1}}
                frictionVsSlipGraph[] = {{0, 1}, {0.5, 1}, {1,1}};
            };
            class LR: LF
            {
                boneName = "wheel_1_2_damper";
                steering = false;
                center   = "wheel_1_2_axis";
                boundary = "wheel_1_2_bound";
                suspForceAppPointOffset = "wheel_1_2_axis";
                tireForceAppPointOffset = "wheel_1_2_axis";
                maxHandBrakeTorque = 3000;
                latStiffY = 180;
                sprungMass = 190.0;
                springStrength = 4750;
                springDamperRate = 1760;
            };
            class RF: LF
            {
                boneName = "wheel_2_1_damper";
                center   = "wheel_2_1_axis";
                boundary = "wheel_2_1_bound";
                suspForceAppPointOffset = "wheel_2_1_axis";
                tireForceAppPointOffset = "wheel_2_1_axis";
                steering = true;
                side = "right";
            };
            class RR: RF
            {
                boneName = "wheel_2_2_damper";
                steering = false;
                center   = "wheel_2_2_axis";
                boundary = "wheel_2_2_bound";
                suspForceAppPointOffset = "wheel_2_2_axis";
                tireForceAppPointOffset = "wheel_2_2_axis";
                maxHandBrakeTorque = 3000;
                latStiffY = 180;
                sprungMass = 190.0;
                springStrength = 4750;
                springDamperRate = 1760;
            };
        };

hope that help you 🙂

Share this post


Link to post
Share on other sites

Please sign in to comment

You will be able to leave a comment after signing in



Sign In Now
Sign in to follow this  

×