void Awake()
{
GetComponent <HingeJoint>().useSpring = true;
// Callback to the activate/deactivate methods from server
GetComponent <ObstacleNetworking>().ActivateFromServer += ActivateFlipper;
GetComponent <ObstacleNetworking>().DeactivateFromServer += DeactivateFlipper;
spring = new JointSpring();
}
/// <summary>
/// Set Rear Suspension Spring Damper.
/// </summary>
public static void SetRearSuspensionsSpringDamper(RCC_CarControllerV3 car, float targetValue)
{
JointSpring spring = car.RearLeftWheelCollider.GetComponent <WheelCollider> ().suspensionSpring;
spring.damper = targetValue;
car.RearLeftWheelCollider.GetComponent <WheelCollider> ().suspensionSpring = spring;
car.RearRightWheelCollider.GetComponent <WheelCollider> ().suspensionSpring = spring;
UpdateRCC(car);
}
private void setServoAngle(HingeJoint servo, float angle)
{
JointSpring hingeSpring = servo.spring;
hingeSpring.spring = maxSpring;
hingeSpring.damper = 3;
hingeSpring.targetPosition = angle;
servo.spring = hingeSpring;
servo.useSpring = true;
}
void Start()
{
rb = GetComponent <Rigidbody>();
lr = GetComponent <LineRenderer>();
rb.centerOfMass = Vector3.zero;
hj = GetComponent <HingeJoint>();
hj.axis = Vector3.up;
hj.useSpring = true;
jointSpring = hj.spring;
}
private void Update()
{
if (Input.GetButtonDown("Fire1"))
{
JointSpring spring = m_Joint.spring;
m_Index = ++m_Index % m_Targets.Length;
spring.targetPosition = m_Targets[m_Index];
m_Joint.spring = spring;
}
}
/// <summary>
/// Set Front Suspension Spring Force.
/// </summary>
public static void SetFrontSuspensionsSpringForce(RCC_CarControllerV3 car, float targetValue)
{
JointSpring spring = car.FrontLeftWheelCollider.GetComponent <WheelCollider> ().suspensionSpring;
spring.spring = targetValue;
car.FrontLeftWheelCollider.GetComponent <WheelCollider> ().suspensionSpring = spring;
car.FrontRightWheelCollider.GetComponent <WheelCollider> ().suspensionSpring = spring;
UpdateRCC(car);
}
void Start()
{
hinge = GetComponent <HingeJoint>();
hingeSpring = hinge.spring;
hingeSpring.spring = 5000;
hingeSpring.damper = 4000;
hingeSpring.targetPosition = 36.86993f;
hinge.spring = hingeSpring;
hinge.useSpring = true;
}
public float closeAngle = -30; // 閉じる角度
// Start is called before the first frame update
void Start()
{
Debug.Log("Start() - GameMainContloller");
_hingeJointL = _objFlipperL.GetComponent <HingeJoint>();
_jointSpringL = _hingeJointL.spring;
_hingeJointR = _objFlipperR.GetComponent <HingeJoint>();
_jointSpringR = _hingeJointR.spring;
// ボールを初期位置に移動
InitBall();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Awake()
{
AIVehicle = transform.GetComponent <AIVehicle>();
if (carParticles.brakeParticleMaterial)
{
carParticles.brakeParticlePerfab.GetComponent <ParticleSystemRenderer>().material = carParticles.brakeParticleMaterial;
}
if (carSetting.automaticGear)
{
NeutralGear = false;
}
myRigidbody = transform.GetComponent <Rigidbody>();
wheels = new WheelComponent[4];
wheels[0] = SetWheelComponent(carWheels.wheels.frontRight, carSetting.maxSteerAngle, carWheels.wheels.frontWheelDrive, carWheels.wheels.frontRight.position.y);
wheels[1] = SetWheelComponent(carWheels.wheels.frontLeft, carSetting.maxSteerAngle, carWheels.wheels.frontWheelDrive, carWheels.wheels.frontLeft.position.y);
wheels[2] = SetWheelComponent(carWheels.wheels.backRight, 0, carWheels.wheels.backWheelDrive, carWheels.wheels.backRight.position.y);
wheels[3] = SetWheelComponent(carWheels.wheels.backLeft, 0, carWheels.wheels.backWheelDrive, carWheels.wheels.backLeft.position.y);
if (carSetting.carSteer)
{
steerCurAngle = carSetting.carSteer.localEulerAngles;
}
foreach (WheelComponent w in wheels)
{
WheelCollider col = w.collider;
col.suspensionDistance = carWheels.setting.Distance;
JointSpring js = col.suspensionSpring;
js.spring = carSetting.springs;
js.damper = carSetting.dampers;
col.suspensionSpring = js;
col.radius = carWheels.setting.Radius;
col.mass = carWheels.setting.Weight;
WheelFrictionCurve fc = col.forwardFriction;
fc.asymptoteValue = 5000.0f;
fc.extremumSlip = 2.0f;
fc.asymptoteSlip = 20.0f;
fc.stiffness = carSetting.stiffness;
col.forwardFriction = fc;
fc = col.sidewaysFriction;
fc.asymptoteValue = 7500.0f;
fc.asymptoteSlip = 2.0f;
fc.stiffness = carSetting.stiffness;
col.sidewaysFriction = fc;
}
}
void Start()
{
RenderSettings.fogDensity = 0.001f;
VisualizeWheel(FL, FR, RL, RR, FLMesh, FRMesh, RLMesh, RRMesh);
rb = GetComponent <Rigidbody>();
audioSource = GetComponent <AudioSource>();
_carFollower = GameObject.Find("CarFollower").GetComponent <Camera>();
_springJoint = new JointSpring();
_springJoint.spring = 8000;
_springJoint.damper = 5000;
_springJoint.targetPosition = 0.85f;
// steering first initialize
if (!LogitechGSDK.LogiSteeringInitialize(false))
{
Debug.Log("LogiInitialize return false");
}
velocityText.text = "0 km/h";
gearText.text = "N";
for (int i = 0; i < GearBox.Length; i++)
{
GearBox[i] = (Shift)ScriptableObject.CreateInstance(typeof(Shift));
if (i > 1)
{
GearBox[i].minSpeed = (i - 2) * 80;
GearBox[i].maxSpeed = (i - 2) * 80 + 80;
GearBox[i].shift = (char)(i - 1);
GearBox[i].id = i;
continue;
}
if (i == 0)
{
GearBox[0].minSpeed = 0;
GearBox[0].maxSpeed = 50;
GearBox[0].shift = 'R';
GearBox[0].id = 0;
}
else
{
GearBox[1].minSpeed = 0;
GearBox[1].maxSpeed = 0;
GearBox[1].shift = 'N';
GearBox[1].id = 1;
}
}
Gear = (Shift)ScriptableObject.CreateInstance(typeof(Shift));
Gear = GearBox[1];
tempGear = 1;
steerState = new LogitechGSDK.DIJOYSTATE2ENGINES();
StartUp();
Invoke(nameof(Idle), 0.65f);
}
void Tense()
{
if (!tensed)
{
JointSpring tempSpring = GetComponent <HingeJoint> ().spring;
tempSpring.targetPosition = GetComponent <HingeJoint>().angle;
GetComponent <HingeJoint> ().spring = tempSpring;
GetComponent <HingeJoint> ().useSpring = true;
tensed = true;
}
}
private void OnDisable()
{
JointSpring js = hj.spring;
js.targetPosition = 0;
Debug.Log("in");
if (this.transform.GetChild(0).GetComponent <legBackmov>())
{
this.transform.GetChild(0).GetComponent <legBackmov>().enabled = true;
}
}
protected void Start()
{
_Velocity = GetComponent <Rigidbody>().velocity.magnitude;
rb = GetComponent <Rigidbody>();
centralCapcollide = GetComponent <CapsuleCollider>();
hs1 = hj1.spring;
hs2 = hj2.spring;
armRange = 0.0f;
}
// Use this for initialization
void Start()
{
//HingeJointコンポーネント取得
this.myHingeJoint = GetComponent <HingeJoint>();
//フリッパーの傾きを設定
JointSpring rot = this.myHingeJoint.spring;
rot.targetPosition = this.defaultAngle;
this.myHingeJoint.spring = rot;
}
private void ToggleBridge()
{
foreach (HingeJoint joint in m_Joints)
{
JointSpring spring = joint.spring;
spring.targetPosition = m_Targets[m_CurrentTarget];
joint.spring = spring;
}
m_CurrentTarget = ++m_CurrentTarget % m_Targets.Length;
}
public void Init(VehicleSetUpData vehicleSetUpData, AxleData axleData)
{
//m_vehicleInput = vehicleInput;
//VehicleData
m_maxBrakingTorque = vehicleSetUpData.MaxBrakingTorque;
m_handBrakeTorque = vehicleSetUpData.HandBrakeTorque;
m_maxEngineTorque = vehicleSetUpData.MaxEngineTorque;
//WheelData
m_maxWheelAngle = axleData.MaxSteerinAngle;
m_collider = gameObject.AddComponent <WheelCollider>();
//Protperties
m_collider.mass = axleData.WheelData.WheelMass;
m_collider.radius = axleData.WheelData.WheelRadius;
m_collider.wheelDampingRate = axleData.WheelData.WheelDampingRate;
m_collider.suspensionDistance = axleData.WheelData.SuspensionDistance;
m_collider.forceAppPointDistance = axleData.WheelData.ForceAppPointDistance;
m_collider.center = axleData.WheelData.Center;
//Spring
JointSpring tempSpring = m_collider.suspensionSpring;
tempSpring.spring = axleData.WheelData.Spring;
tempSpring.damper = axleData.WheelData.Damper;
tempSpring.targetPosition = axleData.WheelData.TargetPosition;
m_collider.suspensionSpring = tempSpring;
//forward
WheelFrictionCurve forwardFriction = m_collider.forwardFriction;
forwardFriction.extremumSlip = axleData.WheelData.ExtremiumSlipForward;
forwardFriction.extremumValue = axleData.WheelData.ExtremiumValueForward;
forwardFriction.asymptoteSlip = axleData.WheelData.AsymptoteSlipForward;
forwardFriction.asymptoteValue = axleData.WheelData.AsymptoteValueForward;
m_collider.forwardFriction = forwardFriction;
//Sideways
WheelFrictionCurve sidewaysFriction = m_collider.sidewaysFriction;
sidewaysFriction.extremumSlip = axleData.WheelData.ExtremiumSlipSideways;
sidewaysFriction.extremumValue = axleData.WheelData.ExtremiumValueSideways;
sidewaysFriction.asymptoteSlip = axleData.WheelData.AsymptoteSlipSideways;
sidewaysFriction.asymptoteValue = axleData.WheelData.AsymptoteValueSideways;
m_collider.sidewaysFriction = sidewaysFriction;
//VIEW
m_model = Instantiate <GameObject>(axleData.WheelData.Model, Vector3.zero, Quaternion.identity, transform);
m_model.transform.localScale = Vector3.one * axleData.WheelData.WheelRadius;
UpdateModel();
}
// Use this for initialization
void Start()
{
WheelCollider wheel = GetComponent <WheelCollider>();
JointSpring tmpSpr = wheel.suspensionSpring;
tmpSpr.spring = 3000f;
tmpSpr.damper = 20f;
wheel.suspensionSpring = tmpSpr;
}
private void UpdateHingeJoints()
{
// Front Part
if (inputMngr.RightButtonUnrealised)
{
if (!hingeFrontUnfold)
{
hingeFrontUnfold = true;
SoundChannelManager.GetInstance().PlayClipAtPoint(hingeUnfold, leftFrontHinge.transform);
}
JointSpring JPTemp = leftFrontHinge.spring;
JPTemp.targetPosition = -10;
leftFrontHinge.spring = JPTemp;
rightFrontHinge.spring = JPTemp;
}
else
{
if (hingeFrontUnfold)
{
hingeFrontUnfold = false;
SoundChannelManager.GetInstance().PlayClipAtPoint(hingeFold, leftFrontHinge.transform);
}
JointSpring JPTemp = leftFrontHinge.spring;
JPTemp.targetPosition = -120;
leftFrontHinge.spring = JPTemp;
rightFrontHinge.spring = JPTemp;
}
// Back Part
if (inputMngr.LeftButtonUnrealised)
{
if (!hingeBackUnfold)
{
hingeBackUnfold = true;
SoundChannelManager.GetInstance().PlayClipAtPoint(hingeUnfold, leftBackHinge.transform);
}
JointSpring JPTemp = leftBackHinge.spring;
JPTemp.targetPosition = -10;
leftBackHinge.spring = JPTemp;
rightBackHinge.spring = JPTemp;
}
else
{
if (hingeBackUnfold)
{
hingeBackUnfold = false;
SoundChannelManager.GetInstance().PlayClipAtPoint(hingeFold, leftBackHinge.transform);
}
JointSpring JPTemp = leftBackHinge.spring;
JPTemp.targetPosition = -120;
leftBackHinge.spring = JPTemp;
rightBackHinge.spring = JPTemp;
}
}
public void hingeDoor()
{
// Debug.Log("test");
HingeJoint hinge = GetComponent <HingeJoint>();
JointSpring spring = hinge.spring;
spring.spring = haneru;
spring.damper = 3;
spring.targetPosition = kakudo;
hinge.spring = spring;
}
// Update is called once per frame
void FixedUpdate()
{
GameObject go = GameObject.Find("CGA Model Manager");
ArmDemo2 ArmFrame = go.GetComponent <ArmDemo2> ();
float Angle_B = ArmFrame.Angle_B;
JointSpring spr = hinge.spring;
spr.targetPosition = -Angle_B + 36.87023f;
hinge.spring = spr;
}
private void Start()
{
m_hingeJoint = GetComponent <HingeJoint>();
m_hingeJoint.useSpring = true;
m_jointSpring = new JointSpring();
m_jointSpring.spring = m_fSpringConst;
m_jointSpring.damper = m_fFlipperSpringDamp;
m_hingeJoint.spring = m_jointSpring;
}
void Start()
{
isFlipup = false;
_hingeJoint = GetComponent <HingeJoint> ();
_hingeJoint.useSpring = true;
JointSpring js = _hingeJoint.spring;
js.spring = power;
js.damper = 0;
_hingeJoint.spring = js;
}
public void ConfigHingeJoint_usingSpring(HingeJoint hingeX, float targetPosition)
{
hingeX.useMotor = false;
hingeX.useSpring = use_spring;
JointSpring hingeXSpring = hingeX.spring;
hingeXSpring.spring = springConst;
hingeXSpring.damper = damperConst;
hingeXSpring.targetPosition = targetPosition;
hingeX.spring = hingeXSpring;
}
private void UpdateJoint()
{
float visualAngle = GetAngle() - initialAngle;
JointSpring spring = joint.spring;
spring.targetPosition = visualAngle;
joint.spring = spring;
}
// Set Angle (if can)
public void SetAngle(float angle)
{
if (!canTurn)
{
return;
}
JointSpring newSpring = turnHinge.spring;
newSpring.targetPosition = angle;
turnHinge.spring = newSpring;
}
void SetSusValue(string Direction)
{
//Create gameobject & Set transform
GameObject Temp_Object = new GameObject("Suspension_" + Direction + "_" + Count);
Temp_Object.transform.parent = Parent_Transform;
Temp_Object.transform.localPosition = new Vector3(SusPos_X, SusPos_Y, SusPos_Z);
Temp_Object.transform.localRotation = Quaternion.Euler(0.0f, Sus_AngleProp.floatValue, -90.0f);
// Mesh
Temp_Object.AddComponent <MeshRenderer> ();
MeshFilter Temp_MeshFilter;
Temp_MeshFilter = Temp_Object.AddComponent <MeshFilter> ();
if (Direction == "R")
{
Temp_MeshFilter.mesh = Sus_R_MeshProp.objectReferenceValue as Mesh;
Temp_Object.GetComponent <Renderer>().material = Sus_R_MaterialProp.objectReferenceValue as Material;
}
else
{
Temp_MeshFilter.mesh = Sus_L_MeshProp.objectReferenceValue as Mesh;
Temp_Object.GetComponent <Renderer>().material = Sus_L_MaterialProp.objectReferenceValue as Material;
}
// Rigidbody
Temp_Object.AddComponent <Rigidbody> ();
Temp_Object.GetComponent <Rigidbody>().mass = Sus_MassProp.floatValue;
// HingeJoint
HingeJoint Temp_HingeJoint;
Temp_HingeJoint = Temp_Object.AddComponent <HingeJoint> ();
Temp_HingeJoint.connectedBody = Parent_Transform.parent.gameObject.GetComponent <Rigidbody>();
Temp_HingeJoint.anchor = new Vector3(0.0f, 0.0f, Sus_AnchorProp.floatValue);
Temp_HingeJoint.axis = new Vector3(1.0f, 0.0f, 0.0f);
Temp_HingeJoint.useSpring = true;
JointSpring Temp_JointSpring = Temp_HingeJoint.spring;
Temp_JointSpring.spring = Sus_SpringProp.floatValue;
Temp_JointSpring.damper = Sus_DamperProp.floatValue;
Temp_JointSpring.targetPosition = Sus_TargetProp.floatValue;
Temp_HingeJoint.spring = Temp_JointSpring;
Temp_HingeJoint.useLimits = true;
JointLimits Temp_JointLimits = Temp_HingeJoint.limits;
Temp_JointLimits.max = Sus_Forward_LimitProp.floatValue;
Temp_JointLimits.min = -Sus_Backward_LimitProp.floatValue;
Temp_HingeJoint.limits = Temp_JointLimits;
// Reinforce SphereCollider
SphereCollider Temp_SphereCollider;
Temp_SphereCollider = Temp_Object.AddComponent <SphereCollider> ();
Temp_SphereCollider.radius = Reinforce_RadiusProp.floatValue;
// Set Layer
Temp_Object.layer = 10; // Ignore All
}
// update joint target position with the given value
public void UpdateJointAngle(float jointValue, string jointName)
{
partsHashTable[jointName].GetComponent <Rigidbody> ().WakeUp();
JointSpring spring = jointsHashTable[jointName].spring;
spring.spring = jointSpringForce;
spring.damper = jointDamperForce;
spring.targetPosition = jointValue;
jointsHashTable[jointName].spring = spring;
jointsHashTable[jointName].useSpring = true;
}
public void Rest()
{
JointSpring spring = new JointSpring
{
spring = hitStrength,
damper = flipperDamper
};
spring.targetPosition = restPosition;
m_hinge.spring = spring;
}
/// <summary>
/// Check which direction the lever needs to be pushed in and
/// switch spring direction as necessary
/// </summary>
private void ApplySpringForce()
{
// get normalized value
towardZero = (GetNormalizedValue() <= 50);
if (towardZero != wasTowardZero)
{
JointSpring spring = hj.spring;
spring.targetPosition = (towardZero) ? minAngle : maxAngle;
hj.spring = spring;
wasTowardZero = towardZero;
}
}
private void SetupBackLever()
{
JointSpring spring = joint.spring;
spring.spring = backForce;
spring.targetPosition = 0.0f;
joint.spring = spring;
joint.useMotor = false;
joint.useSpring = true;
}
private void INTERNAL_get_spring(out JointSpring value){}
private void INTERNAL_set_suspensionSpring(ref JointSpring value){}
private void INTERNAL_get_suspensionSpring(out JointSpring value){}
private void INTERNAL_set_spring(ref JointSpring value){}
