USARBot.KDTrack

class KDTrack extends KTire config(USARBot) abstract;

var float          Radius;

var class<KTire>   AuxTireClass;
var vector         ATPos;
var float          ATRadius;
var KTire          AuxTire;

var class<KTire>   TrackTireClass;
var array<KTire>   TTires;
var float          TTRadius;
var config int     MaxTTiresNum;
var int            TTiresNum;

// KCarWheelJoint settings
var float          SuspHighLimit;
var float          SuspLowLimit; 
var float          SuspStiffness;
var float          SuspDamping;  
                   
var float          lastKMotorTorque;
var float          lastKMaxSpeed;
var float          lastKBraking;

var float          ATRatio;
var float          TTRatio;


struct pvector {
    var float X;
    var float Y;
    var float Z;
};

var pvector        RS_TiresPos[17];
//var Quat		   RS_TiresQuat[17];
var vector         RS_TiresLinVel[17];
//var vector		   RS_TiresAngVel[17];
var byte           RS_UpdateId;

var byte           last_RS_UpdateId;
var float          NextNetUpdateTime;
var float          MaxNetUpdateInterval;

replication
{
    reliable if(Level.NetMode == NM_DedicatedServer)
        RS_TiresPos, /*RS_TiresQuat,*/ RS_TiresLinVel, /*RS_TiresAngVel,*/ RS_UpdateId;
}

simulated function vector toVector(pVector pv)
{
    local vector vec;
    vec.X = pv.X;
    vec.Y = pv.Y;
    vec.Z = pv.Z;
    return vec;
}

simulated function pVector toPVector(vector vec)
{
    local pVector pv;
    pv.X = vec.X;
    pv.Y = vec.Y;
    pv.Z = vec.Z;
    return pv;
}

simulated function PostNetBeginPlay()
{
    local int i;
    local float len, rOff, lOff, tLen, sinValue, cosValue;
    local vector pos, step;
    local vector RotX, RotY, RotZ, relPos;
    
    Super.PostNetBeginPlay();
    if (MaxTTiresNum>16) MaxTTiresNum=16;
    
    GetAxes(Owner.Rotation,RotX,RotY,RotZ);
    relPos = (Location-Owner.Location)<<Owner.Rotation;
    
    AuxTire = spawn(AuxTireClass,Owner,,Location+ATPos.X*RotX+ATPos.Y*RotY+ATPos.Z*RotZ);
    AuxTire.WheelJoint = spawn(class'KCarWheelJoint',Owner);
    //Set primary constraint params
    AuxTire.WheelJoint.KConstraintActor1 = Owner;
    AuxTire.WheelJoint.KPos1 = (relPos+ATPos)/50;
    AuxTire.WheelJoint.KPriAxis1 = vect(0,0,1);
    AuxTire.WheelJoint.KSecAxis1 = vect(0,1,0);
    //Set secondary constraint params
    AuxTire.WheelJoint.KConstraintActor2 = AuxTire;
    AuxTire.WheelJoint.KPos2 = vect(0,0,0);
    AuxTire.WheelJoint.KPriAxis2 = vect(0,0,1);
    AuxTire.WheelJoint.KSecAxis2 = vect(0,1,0);

    AuxTire.WheelJoint.KSuspHighLimit = SuspHighLimit;
    AuxTire.WheelJoint.KSuspLowLimit  = SuspLowLimit;
    AuxTire.WheelJoint.KSuspStiffness = SuspStiffness;
    AuxTire.WheelJoint.KSuspDamping   = SuspDamping;
    AuxTire.WheelJoint.SetPhysics(PHYS_Karma);

    lOff = Sqrt((Radius+TTRadius)*(Radius+TTRadius)-(Radius-TTRadius)*(Radius-TTRadius));
    rOff = Sqrt((ATRadius+TTRadius)*(ATRadius+TTRadius)-(ATRadius-TTRadius)*(ATRadius-TTRadius));
    tLen = Sqrt(ATPos.X*ATPos.X-(Radius-ATRadius)*(Radius-ATRadius));
    len =  tLen - lOff - rOff;
    TTiresNum = Min(MaxTTiresNum,2*Ceil(len/TTRadius/2+1));
    if (ATPos.X<0) {
        tLen = -tLen;
        len = -len;
        lOff = -lOff;
    }
    sinValue = (Radius-ATRadius)/tLen;
    cosValue = ATPos.X/tLen;
    pos.X = (Radius-TTRadius)*sinValue + lOff*cosValue;
    pos.Z = (Radius-TTRadius)*cosValue - lOff*sinValue;
    step.X = (2*len/(TTiresNum-2))*cosValue;
    step.Z = -(2*len/(TTiresNum-2))*sinValue;
    for (i=0;i<TTiresNum;i+=2) {
        TTires[i] = spawn(TrackTireClass,Owner,,Location+pos.X*RotX+pos.Y*RotY+pos.Z*RotZ);
        TTires[i].WheelJoint = spawn(class'KCarWheelJoint',Owner);
        TTires[i].WheelJoint.KConstraintActor1 = Owner;
        TTires[i].WheelJoint.KPos1 = (relPos+pos)/50;
        TTires[i].WheelJoint.KPriAxis1 = vect(0,0,1);
        TTires[i].WheelJoint.KSecAxis1 = vect(0,1,0);
        TTires[i].WheelJoint.KConstraintActor2 = TTires[i];
        TTires[i].WheelJoint.KPos2 = vect(0,0,0);
        TTires[i].WheelJoint.KPriAxis2 = vect(0,0,1);
        TTires[i].WheelJoint.KSecAxis2 = vect(0,1,0);
        TTires[i].WheelJoint.KSuspHighLimit = SuspHighLimit;
        TTires[i].WheelJoint.KSuspLowLimit  = SuspLowLimit;
        TTires[i].WheelJoint.KSuspStiffness = SuspStiffness;
        TTires[i].WheelJoint.KSuspDamping   = SuspDamping;
        TTires[i].WheelJoint.SetPhysics(PHYS_Karma);

        pos.Z = -pos.Z;
        TTires[i+1] = spawn(TrackTireClass,Owner,,Location+pos.X*RotX+pos.Y*RotY+pos.Z*RotZ);
        TTires[i+1].WheelJoint = spawn(class'KCarWheelJoint',Owner);
        TTires[i+1].WheelJoint.KConstraintActor1 = Owner;
        TTires[i+1].WheelJoint.KPos1 = (relPos+pos)/50;
        TTires[i+1].WheelJoint.KPriAxis1 = vect(0,0,1);
        TTires[i+1].WheelJoint.KSecAxis1 = vect(0,1,0);
        TTires[i+1].WheelJoint.KConstraintActor2 = TTires[i+1];
        TTires[i+1].WheelJoint.KPos2 = vect(0,0,0);
        TTires[i+1].WheelJoint.KPriAxis2 = vect(0,0,1);
        TTires[i+1].WheelJoint.KSecAxis2 = vect(0,1,0);
        TTires[i+1].WheelJoint.KSuspHighLimit = SuspHighLimit;
        TTires[i+1].WheelJoint.KSuspLowLimit  = SuspLowLimit;
        TTires[i+1].WheelJoint.KSuspStiffness = SuspStiffness;
        TTires[i+1].WheelJoint.KSuspDamping   = SuspDamping;
        TTires[i+1].WheelJoint.SetPhysics(PHYS_Karma);
        
        pos.Z = -pos.Z;
        pos += step;
    }
    
    KUpdateParams();
    
    ATRatio = Radius/ATRadius;
    TTRatio = Radius/TTRadius;
}

simulated event KUpdateParams()
{
    local int i;
    
    AuxTire.WheelJoint.KUpdateConstraintParams();
    for (i=0;i<TTires.length;i++)
        TTires[i].WheelJoint.KUpdateConstraintParams();
}

simulated event Destroyed()
{
   local int i;
   
   AuxTire.WheelJoint.Destroy();
   AuxTire.Destroy();
   for(i=0;i<TTires.length;i++) {
      TTires[i].WheelJoint.Destroy();
      TTires[i].Destroy();
   }
   Super.Destroyed();
}

function PackState()
{
    local vector pos,oldPos;
    local KRigidBodyState RBState;
    local int i;

    AuxTire.KGetRigidBodyState(RBState);
    pos = KRBVecToVector(RBState.Position);
    oldPos = toVector(RS_TiresPos[0]);
    
    if ((VSize(oldPos - pos) > 1) || Level.TimeSeconds > NextNetUpdateTime)
        NextNetUpdateTime = Level.TimeSeconds + MaxNetUpdateInterval;
    else
        return;
    
    RS_TiresPos[0] = toPVector(KRBVecToVector(RBState.Position));
    //RS_TiresQuat[0] = RBState.Quaternion;
    RS_TiresLinVel[0] = KRBVecToVector(RBState.LinVel);
    //RS_TiresAngVel[0] = KRBVecToVector(RBState.AngVel);
    for (i=0;i<TTires.length;i++) {
        TTires[i].KGetRigidBodyState(RBState);
        RS_TiresPos[i+1] = toPVector(KRBVecToVector(RBState.Position));
        //RS_TiresQuat[i+1] = RBState.Quaternion;
        RS_TiresLinVel[i+1] = KRBVecToVector(RBState.LinVel);
        //RS_TiresAngVel[i+1] = KRBVecToVector(RBState.AngVel);
    }
    RS_UpdateId += 1;
}

simulated function UndateState()
{
    local int i;
    
    AuxTire.KGetRigidBodyState(AuxTire.ReceiveState);
    AuxTire.ReceiveState.Position = KRBVecFromVector(toVector(RS_TiresPos[0]));
    //AuxTire.ReceiveState.Quaternion = RS_TiresQuat[0];
    AuxTire.ReceiveState.LinVel = KRBVecFromVector(RS_TiresLinVel[0]);
    //AuxTire.ReceiveState.AngVel = KRBVecFromVector(RS_TiresAngVel[0]);
    AuxTire.bReceiveStateNew = true;
    
    for (i=0;i<TTires.length;i++) {
        TTires[i].KGetRigidBodyState(TTires[i].ReceiveState);
        TTires[i].ReceiveState.Position = KRBVecFromVector(toVector(RS_TiresPos[i+1]));
        //TTires[i].ReceiveState.Quaternion = RS_TiresQuat[i+1];
        TTires[i].ReceiveState.LinVel = KRBVecFromVector(RS_TiresLinVel[i+1]);
        //TTires[i].ReceiveState.AngVel = KRBVecFromVector(RS_TiresAngVel[i+1]);
        TTires[i].bReceiveStateNew = true;
    }
    last_RS_UpdateId = RS_UpdateId;
}

simulated function Tick(float Delta)
{
    local int i;
    
    if (WheelJoint==None) return;

    if (Level.NetMode == NM_DedicatedServer) 
        PackState();

    if (Level.NetMode != NM_DedicatedServer && last_RS_UpdateId!=RS_UpdateId)
        UndateState();
    
    if (lastKMotorTorque==WheelJoint.KMotorTorque && 
        lastKMaxSpeed==WheelJoint.KMaxSpeed && 
        lastKBraking==WheelJoint.KBraking)
        return;
    
    AuxTire.WheelJoint.KMotorTorque = WheelJoint.KMotorTorque;
    AuxTire.WheelJoint.KMaxSpeed = ATRatio*WheelJoint.KMaxSpeed;
    AuxTire.WheelJoint.KBraking = WheelJoint.KBraking;
    
    for(i=0;i<TTires.length;i++) {
        TTires[i].WheelJoint.KMotorTorque = WheelJoint.KMotorTorque;
        TTires[i].WheelJoint.KMaxSpeed = TTRatio*WheelJoint.KMaxSpeed;
        TTires[i].WheelJoint.KBraking = WheelJoint.KBraking;
    }
    
    KUpdateParams();
    lastKMotorTorque = WheelJoint.KMotorTorque;
    lastKMaxSpeed = WheelJoint.KMaxSpeed;
    lastKBraking = WheelJoint.KBraking;
}

// NOTE: all the parameters are in UU
// The radius of S_RearWheel is 137uu.
defaultproperties
{
    Radius=5.75
    StaticMesh=StaticMesh'BulldogMeshes.Simple.S_RearWheel'
    DrawScale=0.04200000

    MaxTTiresNum=16
    TrackTireClass=USARBot.TrackTire
    TTRadius=1.37

    AuxTireClass=USARBot.USARTire
    ATRadius=5.75
    ATPos=(X=-13)

    SuspStiffness=150.000000
    SuspDamping=50.000000
    SuspHighLimit=0.0030
    SuspLowLimit=-0.0030
    RollFriction=25.000000
    LateralFriction=25.00000
    SlipRate=0.0003000

    MaxNetUpdateInterval=0.40000
    CollisionRadius=1.000000
    CollisionHeight=1.000000
    Begin Object Class=KarmaParamsRBFull Name=KParams0
        KInertiaTensor(0)=1.800000
        KInertiaTensor(3)=1.800000
        KInertiaTensor(5)=1.800000
        KLinearDamping=0.000000
        KAngularDamping=0.000000
        bHighDetailOnly=False
        bClientOnly=False
        bKDoubleTickRate=True
        Name="KParams0"
    End Object
    KParams=KarmaParamsRBFull'USARBot.KDTrack.KParams0'
}