/// splendid tutorial by RedPhoenix could be found at /// http://forums.bistudio.com/showthread.php?165390-Tutorial-Creating-Custom-Engine-Gearbox-and-Suspension-Vehicle-configuration 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 = 150; /// vehicle can go a bit over, but dramatically decreases thrust fuelCapacity = 20; wheelCircumference = 2.607; /// diameter of 725 Measured diameter 0.830m so wheelCircumference = 2.607; antiRollbarForceCoef = 1.9; /// how strong is the anti-roll bar of vehicle preventing it to lose grip in turns (not any magical stuff, real ARB) antiRollbarForceLimit = 24; /// highest possible force of ARB antiRollbarSpeedMin = 30; /// the roll bar force gets from zero to full in range of min and max speed antiRollbarSpeedMax = 150; /// 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 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // : Defines simulation type of the vehicle. PhysX simulation ends with letter "x", "carx", "tankx" ... // : string // : (required) simulation = "carx"; // : 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. // : float // : 0.0 dampersBumpCoef = 0.05; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Differential parameters ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // : 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. // : string; acceptable values: "all_open", "all_limited", "front_open", "front_limited", "rear_open", "rear_limited" // : "all_limited" differentialType = "all_limited"; // : 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. // : float // : 0.5 frontRearSplit = 0.5; // : 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. // : // : frontBias = 1.5; // : 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. // : float // : 1.3 rearBias = 1.3; // : 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. // : float // : 1.3 centreBias = 1.3; // : 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. // : float // : 10.0 clutchStrength = 15.0; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Engine parameters ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // : Power of the engine in kW. // : float // : (required) enginePower = 100; // : 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. // : float // : 600 which is cca 6000 rounds per minute. maxOmega = 720; // : This is the maximum torque that is ever available from the engine. This is expressed in Newton metres. // : float // : value calculated from enginePower according to http://en.wikipedia.org/wiki/Horsepower#Relationship_with_torque peakTorque = 350; // : 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. // : float, float, float // : 0.08, 2.0, 0.35 dampingRateFullThrottle = 0.08; dampingRateZeroThrottleClutchEngaged = 0.35; dampingRateZeroThrottleClutchDisengaged = 0.35; // : 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. // : Array[i][2] where i = number of samples, maximum 8; // : {{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 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // : Value of minimal gear effectivity to hold current gear. If there is better gear and effectivity is below this value then change gear. // : (0,1) // : Array[i] where i = number of gears // : 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}; // : 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). // : float // : 0.01 switchTime = 0.31; // : 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. // : float // : 2.0 latency = 1.0; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Wheels parameters ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class Wheels { class LF { ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // General parameters ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // : Name of the bone, used for wheel and suspension animations. // : string // : "" boneName = "wheel_1_1_damper"; // : If true, wheel is steerable, false - wheel is fixed. // : bool // : (required) steering = true; // : Defines if wheel is on the right or left side of the vehicle // : string // : "right" side = "left"; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Wheel PX parameters ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // : Center of the wheel (axis) // : memory point // : (required) center = "wheel_1_1_axis"; // : Point on the outside rim of the tire, used to calculate radius of the wheel (distance between center and boundary). // : memory point // : (required) boundary = "wheel_1_1_bound"; // : This is the weight in kg of wheel including both rim and tyre. // : float // : 10.0 mass = 100; // : 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. // : float // : 0.5 * WheelMass * WheelRadius * WheelRadius MOI = 3.3; // :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. // : float // : 0.1 dampingRate = 0.5; // : 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". // : float // : 2500 maxBrakeTorque = 2000; // : 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. // : float // : 2*maxBrakeTorque maxHandBrakeTorque = 4000; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Wheel simulation parameters ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // : 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. // : Array[3] // : {0, -1, 0} suspTravelDirection[] = {0, -1, 0}; // : This is the application point of the suspension force. // : memory point // : center suspForceAppPointOffset = "wheel_1_1_axis"; // : 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. // : memory point // : suspForceAppPointOffset tireForceAppPointOffset = "wheel_1_1_axis"; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Suspension parameters ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // : These values describe the maximum compression and elongation in metres that the spring can support. // : float // : 0.15 maxCompression = 0.15; //0.75*0.2 mMaxDroop = 0.15; // : This is the mass in kg that is supported by the suspension spring. // : float // : vehicleMass/numberOfWheels sprungMass = 475; // 1900/4 // : This is the strength of the suspension spring in Newtons per metre. // springStrength = naturalFrequency * naturalFrequency * sprungMass // : float // : sprungMass*5,0*5,0 //springStrength = 9680; //springStrength = 22600; springStrength = 59375; // = 125 * sprungMass // : 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) // : float // : 0,4*2*sqrt(springStrength*sprungMass) //springDamperRate = 1936; //springDamperRate = 8680; springDamperRate = 10621; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Tire parameters ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // : 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. // : float // : 10000 longitudinalStiffnessPerUnitGravity = 100000; // : These values together describe the lateral stiffness per unit lateral slip (in radians) of the tire. // : float, float // : 25, 180 latStiffX = 25; latStiffY = 18000; // : 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 // : Array[3][2] // : {{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"; }; 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"; }; };