import wildtangent.webdriver.*;
import java.math.*;

public class Truck
{
	Main Parent;

	boolean ActiveRight=false;
	boolean ActiveLeft=false;
	boolean ActiveForward=false;
	boolean ActiveBack=false;
	
	WTModel ShadowModel;

	
	WTContainer TruckBody1;
	WTContainer TruckBody2;
	WTContainer Axle_Front;
	WTContainer Axle_Rear;
	WTContainer DriveShaft_Front;
	WTContainer DriveShaft_Rear;
	WTContainer Tire_Left_Front;
	WTContainer Tire_Right_Front;
	WTContainer Tire_Left_Rear;
	WTContainer Tire_Right_Rear;
	WTContainer Support_Left_Front;
	WTContainer Support_Right_Front;
	WTContainer Support_Left_Rear;
	WTContainer Support_Right_Rear;
	WTContainer Shock_Left_Front;
	WTContainer Shock_Right_Front;
	WTContainer Shock_Left_Rear;
	WTContainer Shock_Right_Rear;
	WTContainer Shadow;
	
	WTContainer BrakeLightLeft;
	WTContainer BrakeLightRight;
	WTContainer CabLight;
	WTContainer ReverseLightLeft;
	WTContainer ReverseLightRight;
	
	WTGroup Shadow_Yaw;
	WTGroup Shadow_Pitch;
	WTGroup DriveShaft_Front_Group;
	WTGroup DriveShaft_Rear_Group;
	WTGroup Support_Target_Left;
	WTGroup Support_Target_Right;
	WTGroup Axle_Target;
	WTGroup Camera_Group;
	WTGroup Truck_Group;
	WTGroup Truck_Pitch_Group;
	WTGroup Truck_Chassis_Group;
	WTGroup Front_Axle_Group;
	WTGroup Rear_Axle_Group;
	WTGroup Tire_Left_Front_Turn;
	WTGroup Tire_Right_Front_Turn;
	WTGroup Tire_Left_Rear_Turn;
	WTGroup Tire_Right_Rear_Turn;
	WTGroup Tire_Left_Front_Group;
	WTGroup Tire_Right_Front_Group;
	WTGroup Tire_Left_Rear_Group;
	WTGroup Tire_Right_Rear_Group;
	WTGroup Tire_Left_Front_Mark;
	WTGroup Tire_Right_Front_Mark;
	WTGroup Tire_Left_Rear_Mark;
	WTGroup Tire_Right_Rear_Mark;
	WTGroup Camera_Seat;
	WTGroup Camera_Target;
	
	WTGroup Movement;
	
	float X=0;
	float Y=0;
	float Z=0;
	int CurrentGear=0;
	int PreviousGear=0;
	int AIState=0;
	int CurrentCheckPoint=1;
	boolean SwitchingGears=false;

	float Angle=0;
	float SkidAngle=0;
	
	float TireTrackAngle=0;
	float TurnRate=0;
	float AxleAngle=0;
	float AccelerationRate=0;
	float CurrentSpeed=0;
	float AngularMomentum=0;
	float ForwardMomentum=0;
	float SidewaysMomentum=0;
	float ChassisBounce=0;
	
	float front_left_height=0;
	float front_right_height=0;
	float rear_left_height=0;
	float rear_right_height=0;

	float front_left_accel=0;
	float front_right_accel=0;
	float rear_left_accel=0;
	float rear_right_accel=0;

	
	boolean front_left_onground=false;
	boolean front_right_onground=false;
	boolean rear_left_onground=false;
	boolean rear_right_onground=false;

	boolean BrakeLightState=false;
	boolean ReverseLightState=false;
	
	
	
	WTVector3D TempVector, TempVector2, TempVector3;
	
	public void init(Main ParentClass, int StartX, int StartY, int StartZ)
	{
		Parent=ParentClass;
	
		X=StartX;
		Y=StartY;
		Z=StartZ;
		Angle=0;
		SkidAngle=0;
		
		// Load a Shadow model for this truck
		ShadowModel = Parent.Wt.createModel("media/models/shadow.wt",0);
		if(Parent.DetailTextures){
			ShadowModel.setTexture(Parent.scene.ShadowTex);
		}
		else{
			ShadowModel.setColor(0,0,0);
			ShadowModel.setMaterial(0,0,0,0,0,0,0);			
		}
		Shadow = Parent.Wt.createContainer();
		Shadow.attach(ShadowModel);
		
		
		// Create Mesh Containers
		TruckBody1 = Parent.Wt.createContainer();	
		TruckBody2 = Parent.Wt.createContainer();	
		Axle_Front = Parent.Wt.createContainer();
		Axle_Rear = Parent.Wt.createContainer();
		DriveShaft_Front = Parent.Wt.createContainer();
		DriveShaft_Rear = Parent.Wt.createContainer();
		Tire_Left_Front = Parent.Wt.createContainer();
		Tire_Right_Front = Parent.Wt.createContainer();
		Tire_Left_Rear = Parent.Wt.createContainer();
		Tire_Right_Rear = Parent.Wt.createContainer();
		Support_Left_Front = Parent.Wt.createContainer();
		Support_Right_Front = Parent.Wt.createContainer();
		Support_Left_Rear = Parent.Wt.createContainer();
		Support_Right_Rear = Parent.Wt.createContainer();
		Shock_Left_Front = Parent.Wt.createContainer();
		Shock_Right_Front = Parent.Wt.createContainer();
		Shock_Left_Rear = Parent.Wt.createContainer();
		Shock_Right_Rear = Parent.Wt.createContainer();
		BrakeLightLeft = Parent.Wt.createContainer();
		BrakeLightRight = Parent.Wt.createContainer();
		CabLight = Parent.Wt.createContainer();
		ReverseLightLeft = Parent.Wt.createContainer();
		ReverseLightRight = Parent.Wt.createContainer();
		
		// ATTACH MESHES TO CONTAINERS
		TruckBody1.attach(Parent.scene.Chassis1);
		TruckBody2.attach(Parent.scene.Chassis2);
		Axle_Front.attach(Parent.scene.Axle);
		Axle_Rear.attach(Parent.scene.Axle);
		DriveShaft_Front.attach(Parent.scene.DriveShaft);
		DriveShaft_Rear.attach(Parent.scene.DriveShaft2);
		Tire_Left_Front.attach(Parent.scene.Wheel_Left);
		Tire_Left_Rear.attach(Parent.scene.Wheel_Left);
		Tire_Right_Front.attach(Parent.scene.Wheel_Right);
		Tire_Right_Rear.attach(Parent.scene.Wheel_Right);
		Support_Left_Front.attach(Parent.scene.SupportBar);
		Support_Right_Front.attach(Parent.scene.SupportBar);
		Support_Left_Rear.attach(Parent.scene.SupportBar2);
		Support_Right_Rear.attach(Parent.scene.SupportBar2);
		Shock_Left_Front.attach(Parent.scene.Shocks);
		Shock_Right_Front.attach(Parent.scene.Shocks);
		Shock_Left_Rear.attach(Parent.scene.Shocks);
		Shock_Right_Rear.attach(Parent.scene.Shocks);

		if(Parent.DetailTextures)BrakeLightLeft.attachBitmap(Parent.scene.BrakeLight,1,1,32,32);
		BrakeLightLeft.setBitmapOpacity(110);
		if(Parent.DetailTextures)BrakeLightRight.attachBitmap(Parent.scene.BrakeLight,1,1,32,32);
		BrakeLightRight.setBitmapOpacity(110);
		if(Parent.DetailTextures)CabLight.attachBitmap(Parent.scene.CabLight,1,1,32,32);
		CabLight.setBitmapOpacity(110);
		if(Parent.DetailTextures)ReverseLightLeft.attachBitmap(Parent.scene.ReverseLight,1,1,32,32);
		ReverseLightLeft.setBitmapOpacity(110);
		if(Parent.DetailTextures)ReverseLightRight.attachBitmap(Parent.scene.ReverseLight,1,1,32,32);
		ReverseLightRight.setBitmapOpacity(110);
		
		// CREATE GROUPS
		Camera_Group = Parent.Wt.createGroup();
		Movement = Parent.Wt.createGroup();	
		
		Truck_Group = Parent.Wt.createGroup();
		Truck_Pitch_Group = Parent.Wt.createGroup();
		Truck_Chassis_Group = Parent.Wt.createGroup();
		Front_Axle_Group = Parent.Wt.createGroup();
		Rear_Axle_Group = Parent.Wt.createGroup();
		Tire_Left_Front_Group = Parent.Wt.createGroup();
		Tire_Right_Front_Group = Parent.Wt.createGroup();
		Tire_Left_Rear_Group = Parent.Wt.createGroup();
		Tire_Right_Rear_Group = Parent.Wt.createGroup();
		Tire_Left_Front_Turn = Parent.Wt.createGroup();
		Tire_Right_Front_Turn = Parent.Wt.createGroup();
		Tire_Left_Rear_Turn = Parent.Wt.createGroup();
		Tire_Right_Rear_Turn = Parent.Wt.createGroup();
		Tire_Left_Front_Mark = Parent.Wt.createGroup();
		Tire_Right_Front_Mark = Parent.Wt.createGroup();
		Tire_Left_Rear_Mark = Parent.Wt.createGroup();
		Tire_Right_Rear_Mark = Parent.Wt.createGroup();
		Support_Target_Left = Parent.Wt.createGroup();
		Support_Target_Right = Parent.Wt.createGroup();
		Axle_Target = Parent.Wt.createGroup();
		DriveShaft_Front_Group = Parent.Wt.createGroup();
		DriveShaft_Rear_Group = Parent.Wt.createGroup();
		Shadow_Yaw = Parent.Wt.createGroup();
		Shadow_Pitch = Parent.Wt.createGroup();
		Camera_Seat = Parent.Wt.createGroup();
		Camera_Target = Parent.Wt.createGroup();
		
		// ADD GROUPS TO THE STAGE
		Parent.scene.Stage.addObject(Camera_Group);
		Parent.scene.Stage.addObject(Shadow_Yaw);
		Parent.scene.Stage.addObject(Shadow_Pitch);
		Parent.scene.Stage.addObject(Movement);
		
		Parent.scene.Stage.addObject(DriveShaft_Front_Group);
		Parent.scene.Stage.addObject(DriveShaft_Rear_Group);
		Parent.scene.Stage.addObject(Truck_Group);
		Parent.scene.Stage.addObject(Truck_Pitch_Group);
		Parent.scene.Stage.addObject(Truck_Chassis_Group);
		Parent.scene.Stage.addObject(Front_Axle_Group);
		Parent.scene.Stage.addObject(Rear_Axle_Group);
		Parent.scene.Stage.addObject(Tire_Left_Front_Group);
		Parent.scene.Stage.addObject(Tire_Right_Front_Group);
		Parent.scene.Stage.addObject(Tire_Left_Rear_Group);
		Parent.scene.Stage.addObject(Tire_Right_Rear_Group);
		Parent.scene.Stage.addObject(Tire_Left_Front_Turn);
		Parent.scene.Stage.addObject(Tire_Right_Front_Turn);
		Parent.scene.Stage.addObject(Tire_Left_Rear_Turn);
		Parent.scene.Stage.addObject(Tire_Right_Rear_Turn);
		Parent.scene.Stage.addObject(Tire_Left_Front_Mark);
		Parent.scene.Stage.addObject(Tire_Right_Front_Mark);
		Parent.scene.Stage.addObject(Tire_Left_Rear_Mark);
		Parent.scene.Stage.addObject(Tire_Right_Rear_Mark);
		Parent.scene.Stage.addObject(Support_Target_Left);
		Parent.scene.Stage.addObject(Support_Target_Right);
		Parent.scene.Stage.addObject(Axle_Target);
		Parent.scene.Stage.addObject(Camera_Seat);
		Parent.scene.Stage.addObject(Camera_Target);
		
		// ADD MESHES TO THE STAGE
		Parent.scene.Stage.addObject(Shadow);
		
		Parent.scene.Stage.addObject(TruckBody1);
		Parent.scene.Stage.addObject(TruckBody2);
		Parent.scene.Stage.addObject(Axle_Front);
		Parent.scene.Stage.addObject(Axle_Rear);
		Parent.scene.Stage.addObject(DriveShaft_Front);
		Parent.scene.Stage.addObject(DriveShaft_Rear);
		Parent.scene.Stage.addObject(Tire_Left_Front);
		Parent.scene.Stage.addObject(Tire_Left_Rear);
		Parent.scene.Stage.addObject(Tire_Right_Front);
		Parent.scene.Stage.addObject(Tire_Right_Rear);
		Parent.scene.Stage.addObject(Support_Left_Front);
		Parent.scene.Stage.addObject(Support_Right_Front);
		Parent.scene.Stage.addObject(Support_Left_Rear);
		Parent.scene.Stage.addObject(Support_Right_Rear);
		Parent.scene.Stage.addObject(Shock_Left_Front);
		Parent.scene.Stage.addObject(Shock_Right_Front);
		Parent.scene.Stage.addObject(Shock_Left_Rear);
		Parent.scene.Stage.addObject(Shock_Right_Rear);
		
		Parent.scene.Stage.addObject(BrakeLightLeft);
		Parent.scene.Stage.addObject(BrakeLightRight);
		Parent.scene.Stage.addObject(CabLight);
		Parent.scene.Stage.addObject(ReverseLightLeft);
		Parent.scene.Stage.addObject(ReverseLightRight);
		
		// ARRANGE GROUPS AND MESHES
		
		Truck_Group.addObject(Truck_Pitch_Group);
			Truck_Pitch_Group.addObject(Truck_Chassis_Group);
				Truck_Chassis_Group.addObject(TruckBody1);
				Truck_Chassis_Group.addObject(TruckBody2);
				Truck_Chassis_Group.addObject(Support_Target_Left);
				Truck_Chassis_Group.addObject(Support_Target_Right);
				Truck_Chassis_Group.addObject(Axle_Target);
				Truck_Chassis_Group.addObject(BrakeLightLeft);
				Truck_Chassis_Group.addObject(BrakeLightRight);
				Truck_Chassis_Group.addObject(CabLight);
				Truck_Chassis_Group.addObject(ReverseLightLeft);
				Truck_Chassis_Group.addObject(ReverseLightRight);
				Truck_Chassis_Group.addObject(Camera_Target);
			
		Truck_Pitch_Group.addObject(Front_Axle_Group);
			Front_Axle_Group.addObject(Axle_Front);
			Front_Axle_Group.addObject(DriveShaft_Front_Group);
				DriveShaft_Front_Group.addObject(DriveShaft_Front);
			Front_Axle_Group.addObject(Support_Left_Front);
			Front_Axle_Group.addObject(Support_Right_Front);
			Front_Axle_Group.addObject(Tire_Left_Front_Turn);
				Tire_Left_Front_Turn.addObject(Tire_Left_Front_Mark);
				Tire_Left_Front_Turn.addObject(Tire_Left_Front_Group);
				Tire_Left_Front_Group.addObject(Tire_Left_Front);
			Front_Axle_Group.addObject(Tire_Right_Front_Turn);
				Tire_Right_Front_Turn.addObject(Tire_Right_Front_Mark);
				Tire_Right_Front_Turn.addObject(Tire_Right_Front_Group);
				Tire_Right_Front_Group.addObject(Tire_Right_Front);
			Front_Axle_Group.addObject(Shock_Left_Front);
			Front_Axle_Group.addObject(Shock_Right_Front);
		
		Truck_Pitch_Group.addObject(Rear_Axle_Group);			
			Rear_Axle_Group.addObject(Axle_Rear);
			Rear_Axle_Group.addObject(DriveShaft_Rear_Group);
				DriveShaft_Rear_Group.addObject(DriveShaft_Rear);
			Rear_Axle_Group.addObject(Support_Left_Rear);
			Rear_Axle_Group.addObject(Support_Right_Rear);
			Rear_Axle_Group.addObject(Tire_Left_Rear_Turn);
				Tire_Left_Rear_Turn.addObject(Tire_Left_Rear_Mark);
				Tire_Left_Rear_Turn.addObject(Tire_Left_Rear_Group);
				Tire_Left_Rear_Group.addObject(Tire_Left_Rear);
			Rear_Axle_Group.addObject(Tire_Right_Rear_Turn);
				Tire_Right_Rear_Turn.addObject(Tire_Right_Rear_Mark);
				Tire_Right_Rear_Turn.addObject(Tire_Right_Rear_Group);
				Tire_Right_Rear_Group.addObject(Tire_Right_Rear);
			Rear_Axle_Group.addObject(Shock_Left_Rear);
			Rear_Axle_Group.addObject(Shock_Right_Rear);
		
		Camera_Target.setPosition(0,4f,0);
		Support_Target_Left.setPosition(-1.2f,0,-.5f);
		Support_Target_Right.setPosition(1.2f,0,-.5f);
		Axle_Target.setPosition(0,0,-.5f);
		BrakeLightLeft.setPosition(-3f,4.5f,-8.3f);		
		BrakeLightRight.setPosition(3f,4.5f,-8.3f);		
		CabLight.setPosition(0f,6.8f,-1.5f);		
		ReverseLightLeft.setPosition(-3f,3.8f,-8.3f);		
		ReverseLightRight.setPosition(3f,3.8f,-8.3f);		
		BrakeLightLeft.setVisible(false);
		BrakeLightRight.setVisible(false);
		CabLight.setVisible(false);
		ReverseLightLeft.setVisible(false);
		ReverseLightRight.setVisible(false);
		
		
		Front_Axle_Group.setPosition(0,0,6.7f);
			DriveShaft_Front.setPosition(0,0,0);
			Tire_Left_Front_Turn.setPosition(-2.7f,0,0);
			Tire_Right_Front_Turn.setPosition(2.7f,0,0);
			Tire_Left_Front_Mark.setPosition(-1.5f,0,0);
			Tire_Right_Front_Mark.setPosition(1.5f,0,0);
			Support_Left_Front.setPosition(-1.85f,0,.3f);
			Support_Right_Front.setPosition(1.85f,0,.3f);
			Shock_Left_Front.setPosition(-1.75f,0,0);
			Shock_Right_Front.setPosition(1.75f,0,0);
			
			
		Rear_Axle_Group.setPosition(0,0,-4f);
			DriveShaft_Rear.setPosition(0,0,0);
			Tire_Left_Rear_Turn.setPosition(-2.7f,0,0);
			Tire_Right_Rear_Turn.setPosition(2.7f,0,0);
			Tire_Left_Rear_Mark.setPosition(-1.5f,0,0);
			Tire_Right_Rear_Mark.setPosition(1.5f,0,0);
			Support_Left_Rear.setPosition(-1.85f,0,-.3f);
			Support_Right_Rear.setPosition(1.85f,0,-.3f);
			Shock_Left_Rear.setPosition(-1.75f,0,0);
			Shock_Right_Rear.setPosition(1.75f,0,0);
				
		Truck_Pitch_Group.setPosition(0,1f,0);
		Truck_Chassis_Group.setPosition(0,0,0);
			
				
		// LINK OBJECTS TO THEIR SUPPORTING TARGETS
		Support_Left_Front.setLookAt(Support_Target_Left);
		Support_Left_Rear.setLookAt(Support_Target_Left);
		Support_Right_Front.setLookAt(Support_Target_Right);
		Support_Right_Rear.setLookAt(Support_Target_Right);
		DriveShaft_Front_Group.setLookAt(Axle_Target);	
		DriveShaft_Rear_Group.setLookAt(Axle_Target);	
		
		Shadow_Yaw.addObject(Shadow_Pitch);
		Shadow_Pitch.addObject(Shadow);
		
		
		Truck_Group.setPosition(X,Y,Z);
		

		
		toGround();
	}	
	
	void turnRight(float TimeElapsed){
		TurnRate+=(Parent.globaldefinitions.TurnAccelerationRate*TimeElapsed);
		if(TurnRate>Parent.globaldefinitions.MaxTurnRate)TurnRate=Parent.globaldefinitions.MaxTurnRate;
		if(TurnRate<0)TurnRate=-1*TurnRate;
	}
	
	void turnLeft(float TimeElapsed){
		TurnRate-=(Parent.globaldefinitions.TurnAccelerationRate*TimeElapsed);
		if(TurnRate<(-1*Parent.globaldefinitions.MaxTurnRate))TurnRate=(-1*Parent.globaldefinitions.MaxTurnRate);
		if(TurnRate>0)TurnRate=-1*TurnRate;
	}

	void accelerate(float TimeElapsed){		
		AccelerationRate+=(Parent.globaldefinitions.AccelerationRate*TimeElapsed);
		if(AccelerationRate>Parent.globaldefinitions.MaxAcceleration)AccelerationRate=Parent.globaldefinitions.MaxAcceleration;
		if(AccelerationRate<0)AccelerationRate=0;
	}
	
	void brake(float TimeElapsed){
		AccelerationRate-=(Parent.globaldefinitions.DecelerationRate*TimeElapsed);
		if(AccelerationRate<Parent.globaldefinitions.MaxAccelerationReverse)AccelerationRate=Parent.globaldefinitions.MaxAccelerationReverse;
		if(AccelerationRate>0)AccelerationRate=0;
	}

	void checkBrakeLights(){

		if(ActiveForward){
			if(CurrentSpeed<0 && !BrakeLightState){
				BrakeLightState=true;
				BrakeLightLeft.setVisible(true);
				BrakeLightRight.setVisible(true);
				CabLight.setVisible(true);
			}
			if(CurrentSpeed>0 && BrakeLightState){
				BrakeLightState=false;
				BrakeLightLeft.setVisible(false);
				BrakeLightRight.setVisible(false);
				CabLight.setVisible(false);
			}			
			if(ReverseLightState){
				ReverseLightState=false;
				ReverseLightLeft.setVisible(false);
				ReverseLightRight.setVisible(false);
			}
		}
		
		if(ActiveBack){
			if(CurrentSpeed>0 && !BrakeLightState){
				BrakeLightState=true;
				BrakeLightLeft.setVisible(true);
				BrakeLightRight.setVisible(true);
				CabLight.setVisible(true);
				if(ReverseLightState){
					ReverseLightState=false;
					ReverseLightLeft.setVisible(false);
					ReverseLightRight.setVisible(false);
					}
			}
			if(CurrentSpeed<0 && BrakeLightState){
				BrakeLightState=false;
				BrakeLightLeft.setVisible(false);
				BrakeLightRight.setVisible(false);
				CabLight.setVisible(false);
			}
			if(CurrentSpeed<0 && !ReverseLightState){
				ReverseLightState=true;
				ReverseLightLeft.setVisible(true);
				ReverseLightRight.setVisible(true);
				}		
		}
		if(!ActiveForward && !ActiveBack){
			if(BrakeLightState){
				BrakeLightState=false;
				BrakeLightLeft.setVisible(false);
				BrakeLightRight.setVisible(false);
				CabLight.setVisible(false);
			}
			if(ReverseLightState){
				ReverseLightState=false;
				ReverseLightLeft.setVisible(false);
				ReverseLightRight.setVisible(false);
			}			
		}
	}
	
	void updateSounds(){
		int NewGear=-1;
		
		if(CurrentSpeed <-.1){
			NewGear=0;
		}
		else if(CurrentSpeed>=-.1 && CurrentSpeed<=1){
			NewGear=1;
		}
		else if(CurrentSpeed>1 && CurrentSpeed<=2){
			NewGear=2;
		}
		else if(CurrentSpeed>2){
			NewGear=3;
		}
		if(NewGear != CurrentGear){
			Parent.scene.Sound_Engine[CurrentGear].stop();
			if(CurrentGear>NewGear)PreviousGear=((CurrentGear*2)+3);
			if(CurrentGear<NewGear)PreviousGear=((CurrentGear*2)+4);
			Parent.soundcontroller.playDepthSound(Parent.scene.Sound_Engine[PreviousGear],false,Parent.mathmethods.camDistance3D(X,Y,Z));		
			Parent.soundcontroller.playDepthSound(Parent.scene.Sound_Shift,false,Parent.mathmethods.camDistance3D(X,Y,Z));		
			SwitchingGears=true;
			CurrentGear=NewGear;
		}	
		else if(SwitchingGears){
			if(!Parent.scene.Sound_Engine[PreviousGear].getIsPlaying()){
				Parent.soundcontroller.playDepthSound(Parent.scene.Sound_Engine[CurrentGear],true,Parent.mathmethods.camDistance3D(X,Y,Z));		
				SwitchingGears=false;
			}
		}
	}
	
	void update(float TimeElapsed){
		float front_left_ground, front_right_ground, rear_left_ground, rear_right_ground;
		float front_left_saved, front_right_saved, rear_left_saved, rear_right_saved;
		float roll_test, roll_test2;
		float last_x, last_z;
		
		if(AIState==1)processAI();
		
		if(ActiveRight)turnRight(TimeElapsed);
		if(ActiveLeft)turnLeft(TimeElapsed);
		if(ActiveForward)accelerate(TimeElapsed);
		if(ActiveBack)brake(TimeElapsed);	
		
		if(AIState==0 && Parent.DetailSoundEffects)updateSounds();
		checkBrakeLights();
		
		if(AccelerationRate!=0 && (front_right_onground || front_left_onground)){
			CurrentSpeed+=(AccelerationRate*TimeElapsed);
			if(CurrentSpeed>Parent.globaldefinitions.TopSpeed)CurrentSpeed=Parent.globaldefinitions.TopSpeed;
			if(CurrentSpeed<Parent.globaldefinitions.TopSpeedReverse)CurrentSpeed=Parent.globaldefinitions.TopSpeedReverse;
		}

		if(!ActiveForward && !ActiveBack){
			if(AccelerationRate>0)AccelerationRate-=(Parent.globaldefinitions.AccelerationRate*TimeElapsed);
			if(AccelerationRate<0)AccelerationRate+=(Parent.globaldefinitions.DecelerationRate*TimeElapsed);
		}
		
		CurrentSpeed+=(ForwardMomentum*TimeElapsed);
		
		if((!front_right_onground && !front_left_onground)){
			if(CurrentSpeed>0){
				CurrentSpeed-=(Parent.globaldefinitions.AirborneSpeedDecay*TimeElapsed);
			}
			if(CurrentSpeed<0){
				CurrentSpeed+=(Parent.globaldefinitions.AirborneSpeedDecay*TimeElapsed);
			}
		}
		else{
			if(CurrentSpeed>0){
				CurrentSpeed-=(Parent.globaldefinitions.SpeedDecay*TimeElapsed);
			}
			if(CurrentSpeed<0){
				CurrentSpeed+=(Parent.globaldefinitions.SpeedDecay*TimeElapsed);
			}
		}
		
		if(TurnRate!=0){
			AxleAngle+=TurnRate;
			if(AxleAngle>Parent.globaldefinitions.TurningRadius){
				AxleAngle=Parent.globaldefinitions.TurningRadius;
				TurnRate=0;
				}
			if(AxleAngle<-1*Parent.globaldefinitions.TurningRadius){
				AxleAngle=-1*Parent.globaldefinitions.TurningRadius;
				TurnRate=0;
				}
			if((!ActiveRight && !ActiveLeft)){
				if(TurnRate>0)TurnRate-=(Parent.globaldefinitions.TurnRateDecay*TimeElapsed);
				if(TurnRate<0)TurnRate+=(Parent.globaldefinitions.TurnRateDecay*TimeElapsed);
				if(TurnRate>=-.2f && TurnRate<=.2f){
					TurnRate=0;
				}
			}
		}
		if(AxleAngle!=0 && !ActiveLeft && !ActiveRight){
			if(AxleAngle>0)AxleAngle-=(Parent.globaldefinitions.AxleAngleDecay*TimeElapsed);
			if(AxleAngle<0)AxleAngle+=(Parent.globaldefinitions.AxleAngleDecay*TimeElapsed);
			if(AxleAngle>=-.3f && AxleAngle<=.3f){
				AxleAngle=0;
			}
		}

		
		if(CurrentSpeed!=0 && (front_right_onground || front_left_onground)){				
			Truck_Group.setRotation(0,1,0,((AxleAngle/(20f/CurrentSpeed))*TimeElapsed));
			Angle+=((AxleAngle/(20f/CurrentSpeed))*TimeElapsed);
			AngularMomentum=AxleAngle;
		}
		else if(CurrentSpeed!=0){
			AngularMomentum/=4f;
			Truck_Group.setRotation(0,1,0,((AngularMomentum/(20f/CurrentSpeed))*TimeElapsed));
			Angle+=((AngularMomentum/(20f/CurrentSpeed))*TimeElapsed);
			SkidAngle+=((AngularMomentum/(20f/CurrentSpeed))*TimeElapsed);
		}
		
		if(SkidAngle!=Angle && (front_right_onground || front_left_onground)){
			if(SkidAngle<Angle-35){
				SkidAngle=Angle-35f;
				if(Parent.DetailSoundEffects)
					if(!Parent.scene.Sound_Skid.getIsPlaying() && !(CurrentSpeed<=1 && CurrentSpeed >=-1))Parent.soundcontroller.playDepthSound(Parent.scene.Sound_Skid,false,Parent.mathmethods.camDistance3D(X,Y,Z));
			}
			if(SkidAngle>Angle+35){
				SkidAngle=Angle+35f;
				if(Parent.DetailSoundEffects)
					if(!Parent.scene.Sound_Skid.getIsPlaying() && !(CurrentSpeed<=1 && CurrentSpeed >=-1))Parent.soundcontroller.playDepthSound(Parent.scene.Sound_Skid,false,Parent.mathmethods.camDistance3D(X,Y,Z));
			}
			if(SkidAngle<Angle){
				SkidAngle+=((Parent.globaldefinitions.TopSpeed-Math.abs(CurrentSpeed)+1)*2f*TimeElapsed);
				if(SkidAngle>Angle)SkidAngle=Angle;
			}
			if(SkidAngle>Angle){
				SkidAngle-=((Parent.globaldefinitions.TopSpeed-Math.abs(CurrentSpeed)+1)*2f*TimeElapsed);
				if(SkidAngle<Angle)SkidAngle=Angle;
			}
			if(SkidAngle<Angle+.5f && SkidAngle >Angle-.5f)SkidAngle=Angle;
			Movement.setOrientation(0,1,0,SkidAngle);
		}
		
		DriveShaft_Rear.setRotation(0,0,1,(CurrentSpeed*20f));
		DriveShaft_Front.setRotation(0,0,1,(CurrentSpeed*20f));
		
		Tire_Left_Front.setRotation(1,0,0,(CurrentSpeed*15f*TimeElapsed));
		Tire_Right_Front.setRotation(1,0,0,(CurrentSpeed*15f*TimeElapsed));
		Tire_Left_Rear.setRotation(1,0,0,(CurrentSpeed*15f*TimeElapsed));		
		Tire_Right_Rear.setRotation(1,0,0,(CurrentSpeed*15f*TimeElapsed));
	
		TireTrackAngle+=CurrentSpeed*15f;
		
		TempVector = Movement.getOrientationVector();
		last_x=X;
		last_z=Z;
		X+=(TempVector.getX()*CurrentSpeed*TimeElapsed);
		Z+=(TempVector.getZ()*CurrentSpeed*TimeElapsed);
		
		if(X<40f || X>960f)X=last_x;
		if(Z<40f || Z>960f)Z=last_z;
		
		Truck_Group.setPosition(X,Y,Z);
		
		ChassisBounce+=(((front_left_accel+front_right_accel+rear_left_accel+rear_right_accel)/9f)*TimeElapsed);
		if(ChassisBounce>0){
			ChassisBounce-=(.1f*TimeElapsed);
			if(ChassisBounce < 0)ChassisBounce=0;
		}
		if(ChassisBounce<0){
			ChassisBounce+=(.1f*TimeElapsed);
			if(ChassisBounce > 0)ChassisBounce=0;
		}
		if(ChassisBounce>.8)ChassisBounce=.8f;
		if(ChassisBounce<-.5)ChassisBounce=-.5f;
		Truck_Chassis_Group.setPosition(0,ChassisBounce,0);
		
		// FIND THE CURRENT POSITION OF ALL TIRES, AND THE HEIGHT OF THE GROUND BENEATH THEM.
		// FRONT LEFT TIRE
		TempVector = Tire_Left_Front.getAbsolutePosition();
		front_left_ground = Parent.world.getTerrainHeight(TempVector.getX(),TempVector.getZ());
		if(front_left_onground && front_left_ground > front_left_height){
			front_left_accel=(front_left_ground-front_left_height);
		}
		if(front_left_onground==true && Parent.gameloop.DustGenCycle==1 && Parent.DetailDustClouds && !(CurrentSpeed<.02 && CurrentSpeed>-.02) && (AccelerationRate < Parent.globaldefinitions.MaxAcceleration-.002f && AccelerationRate > Parent.globaldefinitions.MaxAccelerationReverse+.002f))generateDustCloud(TempVector.getX(),TempVector.getY()-1.5f,TempVector.getZ());
		if(front_left_onground==true && Parent.DetailTreadMarks && !(CurrentSpeed<.02 && CurrentSpeed>-.02) && (TireTrackAngle >=30f || TireTrackAngle<=-30)/* && (SkidAngle>=Angle+30 || SkidAngle<=Angle-30)*/)
		{
			if(Parent.TreadCount<(Parent.MaxTreadCount)){
				TempVector = Tire_Left_Front_Mark.getAbsolutePosition();				
				TempVector2=Tire_Left_Front_Turn.getOrientationVector();
				TempVector3=Tire_Left_Front_Turn.getOrientationUp();
				Parent.TreadList[Parent.TreadCount].create(Parent.TreadCount,TempVector.getX(),TempVector.getY()-2.2f,TempVector.getZ(),TempVector2.getX(),TempVector2.getY(),TempVector2.getZ(),TempVector3.getX(),TempVector3.getY(),TempVector3.getZ());
				Parent.TreadCount++;
			}
		}

		// FRONT RIGHT TIRE
		TempVector = Tire_Right_Front.getAbsolutePosition();
		front_right_ground = Parent.world.getTerrainHeight(TempVector.getX(),TempVector.getZ());
		if(front_right_onground && front_right_ground > front_right_height){
			front_right_accel=(front_right_ground-front_right_height);
		}
		if(front_right_onground==true && Parent.gameloop.DustGenCycle==1 && Parent.DetailDustClouds && !(CurrentSpeed<.02 && CurrentSpeed>-.02) && (AccelerationRate < Parent.globaldefinitions.MaxAcceleration-.002f && AccelerationRate > Parent.globaldefinitions.MaxAccelerationReverse+.002f))generateDustCloud(TempVector.getX(),TempVector.getY()-1.5f,TempVector.getZ());
		if(front_right_onground==true && Parent.DetailTreadMarks && !(CurrentSpeed<.02 && CurrentSpeed>-.02) && (TireTrackAngle >=30f || TireTrackAngle<=-30)/* && (SkidAngle>=Angle+30 || SkidAngle<=Angle-30)*/)
		{
			if(Parent.TreadCount<(Parent.MaxTreadCount)){
				TempVector = Tire_Right_Front_Mark.getAbsolutePosition();				
				TempVector2=Tire_Right_Front_Turn.getOrientationVector();
				TempVector3=Tire_Right_Front_Turn.getOrientationUp();
				Parent.TreadList[Parent.TreadCount].create(Parent.TreadCount,TempVector.getX(),TempVector.getY()-2.2f,TempVector.getZ(),TempVector2.getX(),TempVector2.getY(),TempVector2.getZ(),TempVector3.getX(),TempVector3.getY(),TempVector3.getZ());
				Parent.TreadCount++;
			}
		}
		
		// REAR LEFT TIRE		
		TempVector = Tire_Left_Rear.getAbsolutePosition();
		rear_left_ground = Parent.world.getTerrainHeight(TempVector.getX(),TempVector.getZ());
		if(rear_left_onground && rear_left_ground > rear_left_height){
			rear_left_accel=(rear_left_ground-rear_left_height);
		}		
		if(rear_left_onground==true && Parent.gameloop.DustGenCycle==1 && Parent.DetailDustClouds && !(CurrentSpeed<.02 && CurrentSpeed>-.02) && (SkidAngle>=Angle+30 || SkidAngle<=Angle-30))generateDustCloud(TempVector.getX(),TempVector.getY()-1.5f,TempVector.getZ());
		
		// REAR RIGHT TIRE		
		TempVector = Tire_Right_Rear.getAbsolutePosition();
		rear_right_ground = Parent.world.getTerrainHeight(TempVector.getX(),TempVector.getZ());
		if(rear_right_onground && rear_right_ground > rear_right_height){
			rear_right_accel=(rear_right_ground-rear_right_height);
		}
		if(rear_right_onground==true && Parent.gameloop.DustGenCycle==1 && Parent.DetailDustClouds && !(CurrentSpeed<.02 && CurrentSpeed>-.02) && (SkidAngle>=Angle+30 || SkidAngle<=Angle-30))generateDustCloud(TempVector.getX(),TempVector.getY()-1.5f,TempVector.getZ());
		
		
		// IF OUR TIRE's FOOTPRINT IS READY TO START AGAIN, RESET IT
		if(TireTrackAngle>=30 || TireTrackAngle<=-30)TireTrackAngle=0;
		
		// BASED UPON THE SLOPE OF THE GROUND, FIND THE MOMENTUM THAT THE TRUCK IS GAINING
		if(front_left_onground || front_right_onground || rear_left_onground || rear_right_onground){
			ForwardMomentum=(((((rear_left_ground+rear_right_ground)/2f)-((front_left_ground+front_right_ground)/2f))/200f)*(Math.abs(CurrentSpeed)+1f));
		}
		else{
			ForwardMomentum=0;
		}
		
		front_left_saved=front_left_height;
		front_right_saved=front_right_height;
		rear_left_saved=rear_left_height;
		rear_right_saved=rear_right_height;
		// DROP ALL TIRES ACCORDING TO GRAVITY

		// FRONT LEFT TIRE		
		if(front_left_height>front_left_ground){
			front_left_onground=false;			
			front_left_height+=(front_left_accel*TimeElapsed);
			front_left_accel-=(Parent.globaldefinitions.Gravity*TimeElapsed);
		}
		if(front_left_height<=front_left_ground){
			front_left_height=front_left_ground;
			if(!front_left_onground){
				front_left_accel=(-.25f*front_left_accel*TimeElapsed);
				if(front_left_accel>-.1 && front_left_accel <.1)front_left_accel=0;
				if(Parent.DetailSoundEffects)
					if(front_left_accel>5 && !Parent.scene.Sound_Shocks1.getIsPlaying() && Parent.scene.Sound_Shocks1.getIsLoaded())Parent.soundcontroller.playDepthSound(Parent.scene.Sound_Shocks1,false,Parent.mathmethods.camDistance3D(X,Y,Z));
					
				}
			front_left_onground=true;
		}

		// FRONT RIGHT TIRE
		if(front_right_height>front_right_ground){
			front_right_onground=false;
			front_right_height+=(front_right_accel*TimeElapsed);
			front_right_accel-=(Parent.globaldefinitions.Gravity*TimeElapsed);
		}
		if(front_right_height<=front_right_ground){
			front_right_height=front_right_ground;
			if(!front_right_onground){
				front_right_accel=(-.25f*front_right_accel);
				if(front_right_accel>-.1 && front_right_accel <.1)front_right_accel=0;
				if(Parent.DetailSoundEffects)
					if(front_right_accel>.2 && !Parent.scene.Sound_Shocks1.getIsPlaying() && Parent.scene.Sound_Shocks1.getIsLoaded())Parent.soundcontroller.playDepthSound(Parent.scene.Sound_Shocks1,false,Parent.mathmethods.camDistance3D(X,Y,Z));
				}
			front_right_onground=true;		
		}

		
		// REAR LEFT TIRE
		if(rear_left_height>rear_left_ground){
			rear_left_onground=false;
			rear_left_height+=(rear_left_accel*TimeElapsed);
			rear_left_accel-=(Parent.globaldefinitions.Gravity*TimeElapsed);
		}
		if(rear_left_height<=rear_left_ground){
			rear_left_height=rear_left_ground;
			if(!rear_left_onground){
				rear_left_accel=(-.25f*rear_left_accel);
				if(rear_left_accel>-.1 && rear_left_accel <.1)rear_left_accel=0;
				if(Parent.DetailSoundEffects)
					if(rear_left_accel>.15 && !Parent.scene.Sound_Shocks2.getIsPlaying() && Parent.scene.Sound_Shocks2.getIsLoaded())Parent.soundcontroller.playDepthSound(Parent.scene.Sound_Shocks2,false,Parent.mathmethods.camDistance3D(X,Y,Z));
				}
			rear_left_onground=true;
		}

		// REAR RIGHT TIRE
		if(rear_right_height>rear_right_ground){
			rear_right_onground=false;			
			rear_right_height+=(rear_right_accel);
			rear_right_accel-=(Parent.globaldefinitions.Gravity*TimeElapsed);
		}
		if(rear_right_height<=rear_right_ground){
			rear_right_height=rear_right_ground;
			if(!rear_right_onground){
				rear_right_accel=(-.25f*rear_right_accel);
				if(rear_right_accel>-.1 && rear_right_accel <.1)rear_right_accel=0;
				if(Parent.DetailSoundEffects)
					if(rear_right_accel>.15 && !Parent.scene.Sound_Shocks2.getIsPlaying() && Parent.scene.Sound_Shocks2.getIsLoaded())Parent.soundcontroller.playDepthSound(Parent.scene.Sound_Shocks2,false,Parent.mathmethods.camDistance3D(X,Y,Z));
				}
			rear_right_onground=true;			
		}
		
		
		// MAKE SURE THIS ISN'T AN IMPOSSIBLE TWIST OF THE AXLE
		roll_test = (float)Math.atan((front_right_height-front_left_height)/5f);
		roll_test=(Parent.mathmethods.radiansToDegrees(roll_test));
		
		roll_test2 = (float)Math.atan((rear_right_height-rear_left_height)/5f);
		roll_test2=(Parent.mathmethods.radiansToDegrees(roll_test2));
		
		if(Math.abs(roll_test-roll_test2)>10){
			if(!front_left_onground && !front_right_onground){
				front_left_height+=((front_right_height-front_left_height)/10f);
				front_right_height+=((front_left_height-front_right_height)/10f);
				front_left_onground=false;
				front_right_onground=false;
			}
			if(!rear_left_onground && !rear_right_onground){
				rear_left_height+=((rear_right_height-rear_left_height)/10f);
				rear_right_height+=((rear_left_height-rear_right_height)/10f);
				rear_left_onground=false;
				rear_right_onground=false;
			}
		}
		
		arrangeTruck(front_left_ground, front_right_ground, rear_left_ground, rear_right_ground);
		
	}
	
	void toGround(){
		TempVector = Tire_Left_Front.getAbsolutePosition();
		front_left_height = Parent.world.getTerrainHeight(TempVector.getX(),TempVector.getZ());
		front_left_onground=true;
		front_left_accel=-1;
		TempVector = Tire_Right_Front.getAbsolutePosition();
		front_right_height = Parent.world.getTerrainHeight(TempVector.getX(),TempVector.getZ());
		front_right_onground=true;
		front_right_accel=-1;
		TempVector = Tire_Left_Rear.getAbsolutePosition();
		rear_left_height = Parent.world.getTerrainHeight(TempVector.getX(),TempVector.getZ());
		rear_left_onground=true;		
		rear_left_accel=-1;
		TempVector = Tire_Right_Rear.getAbsolutePosition();
		rear_right_height = Parent.world.getTerrainHeight(TempVector.getX(),TempVector.getZ());
		rear_right_onground=true;
		rear_right_accel=-1;
		arrangeTruck(front_left_height, front_right_height, rear_left_height, rear_right_height);
		
	}
	
	void arrangeTruck(float y1, float y2, float y3, float y4)
	{
		float roll_front,roll_rear,pitch;
		float axle_height_front;
		float axle_height_rear;
		
		// CALCULATE ROLL OF FRONT AXLE
		roll_front = (float)Math.atan((front_right_height-front_left_height)/5f);
		axle_height_front = (front_left_height+front_right_height)/2;

		roll_front=(Parent.mathmethods.radiansToDegrees(roll_front));
		

		// CALCULATE ROLL OF REAR AXLE
		roll_rear = (float)Math.atan((rear_right_height-rear_left_height)/5f);
		axle_height_rear = (rear_left_height+rear_right_height)/2;

		roll_rear=(Parent.mathmethods.radiansToDegrees(roll_rear));
		
		
		Front_Axle_Group.setOrientation(0,0,1,roll_front);
		Rear_Axle_Group.setOrientation(0,0,1,roll_rear);
		Shock_Left_Rear.setOrientation(0,0,1,roll_rear*-.5f);
		Shock_Right_Rear.setOrientation(0,0,1,roll_rear*-.5f);
		
		// CALCULATE THE PITCH OF THE TRUCK		
		pitch = (float)Math.atan((axle_height_rear-axle_height_front)/11.7f);
		pitch = (Parent.mathmethods.radiansToDegrees(pitch));
		
		// PITCH THE TRUCK TO MATCH THE AXLE HEIGHTS
		Truck_Pitch_Group.setOrientation(1,0,0,pitch);
		
		// ROLL THE TRUCK BODY BETWEEN THE TWO AXLES
		Truck_Chassis_Group.setOrientation(0,0,1,(roll_front+roll_rear)/2f);
		
		TempVector = Truck_Group.getAbsolutePosition();
		X=TempVector.getX();
		Z=TempVector.getZ();
		// SET THE TRUCK AT ITS NEW Y POSITION
		Y=(axle_height_front+axle_height_rear)/2;		
		Truck_Group.setPosition(X,Y,Z);

		// POSITION THE SHADOW ALONG THE GROUND
		TempVector = Truck_Group.getOrientationVector();
		Shadow_Yaw.setOrientationVector(TempVector.getX(),TempVector.getY(),TempVector.getZ(),0,1,0);
		pitch = (float)Math.atan((((y3+y4)/2f)-((y1+y2)/2f))/11.7f);
		pitch = (Parent.mathmethods.radiansToDegrees(pitch));
		Shadow_Pitch.setOrientation(1,0,0,pitch);
		
		roll_front = (float)Math.atan((y2-y1)/5f);
		roll_front=(Parent.mathmethods.radiansToDegrees(roll_front));
		roll_rear = (float)Math.atan((y4-y3)/5f);
		roll_rear=(Parent.mathmethods.radiansToDegrees(roll_rear));
		Shadow.setOrientation(0,0,1,(roll_front+roll_rear)/2f);
		
		Shadow_Yaw.setPosition(X,((y1+y2+y3+y4)/4f)-1.3f,Z);
		ShadowModel.setOpacity(150-(int)((((front_left_height+front_right_height+rear_left_height+rear_right_height)/4f)-((y1+y2+y3+y4)/4f))*20));
		// SET THE CURRENT TIRE ANGLES
	
		Tire_Left_Front_Turn.setOrientation(0,1,0,AxleAngle);
		Tire_Right_Front_Turn.setOrientation(0,1,0,AxleAngle);
		Tire_Left_Rear_Turn.setOrientation(0,-1,0,AxleAngle/4f);
		Tire_Right_Rear_Turn.setOrientation(0,-1,0,AxleAngle/4f);
		
	}

	void generateDustCloud(float x, float y, float z){
		if(Parent.DustCount<(Parent.MaxDustCount) && Parent.gameloop.DustCloudCycle==1){
			Parent.DustList[Parent.DustCount].create(Parent.DustCount,x,y,z);
			Parent.DustCount++;
		}
	}
	
	
	void processAI(){
		float TestAngle;
		
		ActiveForward=true;
		
		WTVector3D TempVector = Truck_Group.getOrientationVector();
		
		
		Angle = Parent.mathmethods.radiansToDegrees((float)Math.atan2(TempVector.getX(), TempVector.getZ()));
		
		TestAngle =Parent.mathmethods.radiansToDegrees((float)Math.atan2(Parent.world.CheckPoint[CurrentCheckPoint][0]-X,Parent.world.CheckPoint[CurrentCheckPoint][1]-Z))-Angle;

		if (TestAngle > 180) TestAngle = TestAngle -360;
		if (TestAngle < -180) TestAngle =TestAngle +360;
		if (Angle > 180) Angle = Angle -360;
		if (Angle < -180) Angle =Angle +360;		
		
		
		if(TestAngle>0){
			ActiveRight=true;
			ActiveLeft=false;
		}
		if(TestAngle<0){
			ActiveLeft=true;
			ActiveRight=false;
		}

		if(Z < Parent.world.CheckPoint[CurrentCheckPoint][1]+40f && Z > Parent.world.CheckPoint[CurrentCheckPoint][1]-40f 
		   && X < Parent.world.CheckPoint[CurrentCheckPoint][0]+40f && X > Parent.world.CheckPoint[CurrentCheckPoint][0]-40f)
		{
			CurrentCheckPoint++;
			if(CurrentCheckPoint > Parent.world.CheckPointCount)CurrentCheckPoint=1;
		}

	}
}