public override void Process()
{
base.Process();
if (latched)
{
return;
}
output.SetValue(input.value);
if (showDebug)
{
Debug.Log(base.name + " Latch Setting " + input.value);
}
if (latch.value > 0.5f)
{
if (showDebug)
{
Debug.Log(base.name + " Latch True ");
}
latched = true;
}
}
private void FixedUpdate()
{
float xAngle = joint.GetXAngle(invInitialLocalRotation);
float num;
for (num = xAngle - currentAngle; num < -180f; num += 360f)
{
}
while (num > 180f)
{
num -= 360f;
}
currentAngle += num;
if (num == 0f)
{
return;
}
if (currentAngle < fromAngle + 60f)
{
if (limitJoint == null)
{
limitJoint = CreateLimitJoint(fromAngle - currentAngle, Mathf.Min(fromAngle - currentAngle + 120f, toAngle - currentAngle));
}
}
else if (currentAngle > toAngle - 60f)
{
if (limitJoint == null)
{
limitJoint = CreateLimitJoint(Mathf.Max(toAngle - currentAngle - 120f, fromAngle - currentAngle), toAngle - currentAngle);
}
}
else if (limitJoint != null && currentAngle > fromAngle + 90f && currentAngle < toAngle - 90f)
{
Object.Destroy(limitJoint);
}
currentAngle = Mathf.Clamp(currentAngle, fromAngle, toAngle);
currentValue = Mathf.InverseLerp(fromAngle, toAngle, currentAngle);
output.SetValue((!signedOutput) ? currentValue : Mathf.Lerp(-1f, 1f, currentValue));
}
public override void Process()
{
output.SetValue(in1.value * in2.value);
}
private void RightJointSignal()
{
rightJointBroken.SetValue(1f);
}
private void LeftJointSignal()
{
leftJointBroken.SetValue(1f);
}
public override void Process()
{
output.SetValue(Mathf.Clamp(input.value, min, max));
}
private void Update()
{
for (int i = 0; i < 10; i++)
{
if (!bowlingPins[i].IsInPlace())
{
pinsDownOutputs[i].SetValue(1f);
}
else
{
pinsDownOutputs[i].SetValue(0f);
}
}
switch (currentState)
{
case BowlingState.BowlingState_Complete:
break;
case BowlingState.BowlingState_InitialSetup:
initialSetupTimer += Time.deltaTime;
if (initialSetupTimer >= 3f)
{
for (int n = 0; n < 10; n++)
{
bowlingPins[n].Show();
}
inSpareMode = false;
spareMode.SetValue(0f);
currentState = BowlingState.BowlingState_Ready;
}
break;
case BowlingState.BowlingState_Ready:
if (ballInPinsArea.value > 0.5f)
{
currentState = BowlingState.BowlingState_BallInPins;
pinsKnockDownTimer = 0f;
}
break;
case BowlingState.BowlingState_BallInPins:
{
pinsKnockDownTimer += Time.deltaTime;
pinsDown = 0;
for (int l = 0; l < 10; l++)
{
if (!bowlingPins[l].IsInPlace())
{
pinsDown++;
}
}
if (pinsDown == 10)
{
for (int m = 0; m < 10; m++)
{
bowlingPins[m].Hide();
}
bowlingComplete.SetValue(1f);
currentState = BowlingState.BowlingState_Complete;
}
else if (pinsKnockDownTimer >= 10f)
{
currentState = BowlingState.BowlingState_TidyingPins;
}
break;
}
case BowlingState.BowlingState_TidyingPins:
if (inSpareMode)
{
for (int j = 0; j < 10; j++)
{
bowlingPins[j].Show();
}
inSpareMode = false;
spareMode.SetValue(0f);
}
else
{
for (int k = 0; k < 10; k++)
{
if (!bowlingPins[k].IsInPlace())
{
bowlingPins[k].Hide();
}
}
if (pinsDown != 0)
{
inSpareMode = true;
spareMode.SetValue(1f);
}
}
currentState = BowlingState.BowlingState_Ready;
break;
}
}
private void FixedUpdate()
{
if (identity != null && (ReplayRecorder.isPlaying || NetGame.isClient))
{
return;
}
disableMotorTime -= Time.fixedDeltaTime;
float num = position;
float num2 = direction;
float num3 = power.value / neededVoltage;
if (Mathf.Abs(num3) < 0.9f)
{
num3 = 0f;
}
if (joint != null)
{
if (unpoweredWithoutVoltage)
{
joint.maxForce = ((!(num3 > 0f)) ? 0f : maxForce);
}
if (mode == ServoMode.Position)
{
float num4 = Mathf.Lerp(joint.minValue, joint.maxValue, (!signedInput) ? input.value : ((input.value + 1f) / 2f));
float num5 = num4 - num;
float num6 = (num5 > 0f) ? 1 : ((num5 < 0f) ? (-1) : 0);
speed = Mathf.MoveTowards(speed, num6 * joint.maxSpeed, joint.maxAcceleration * Time.fixedDeltaTime);
position += speed * num3 * Time.fixedDeltaTime;
if (speed < 0f && position < num4 && num > num4)
{
position = num4;
speed = 0f;
}
if (speed > 0f && position > num4 && num < num4)
{
position = num4;
speed = 0f;
}
direction = Mathf.Sign(position - num);
if (direction * num2 < 0f)
{
disableMotorTime = reverseDelay;
}
motor.SetValue((num3 > 0f && disableMotorTime <= 0f && Mathf.Abs(num - num4) >= joint.tensionDist) ? 1 : 0);
}
else
{
if (joint != null)
{
if (speed * input.value < 0f)
{
speed = 0f;
}
speed = Mathf.MoveTowards(speed, input.value * joint.maxSpeed, joint.maxAcceleration * Time.fixedDeltaTime);
position += speed * num3 * Time.fixedDeltaTime;
direction = Mathf.Sign(position - num);
if (direction * num2 < 0f)
{
disableMotorTime = reverseDelay;
}
if (mode == ServoMode.Speed)
{
if (reachedEnd == -1f && input.value * num3 > 0f)
{
reachedEnd = 0f;
}
else if (reachedEnd == 1f && input.value * num3 < 0f)
{
reachedEnd = 0f;
}
else if (position < joint.minValue + joint.tensionDist && input.value * num3 <= 0f)
{
reachedEnd = -1f;
}
else if (position > joint.maxValue - joint.tensionDist && input.value * num3 >= 0f)
{
reachedEnd = 1f;
}
}
}
motor.SetValue((Mathf.Abs(num3) > 0f && disableMotorTime <= 0f && reachedEnd == 0f && input.value != 0f) ? 1 : 0);
}
}
else if (showDebug)
{
Debug.Log(base.name + " There is nothing set within the joint var ");
}
if (num != position || oldpower != num3)
{
if (joint != null)
{
velocity.SetValue(Mathf.Clamp01(Mathf.Abs(position - num) / Time.fixedDeltaTime / joint.maxSpeed));
if (joint.isKinematic || !joint.useSpring)
{
if (mode == ServoMode.Speed)
{
position = Mathf.Clamp(position, joint.minValue, joint.maxValue);
}
SetPosition(position);
}
else
{
actualPosition = GetActualPosition();
position = Mathf.Clamp(position, actualPosition - joint.tensionDist, actualPosition + joint.tensionDist);
float spring = joint.maxForce / joint.tensionDist * Mathf.Abs(num3);
float damper = joint.maxForce / joint.maxSpeed * Mathf.Abs(num3);
SetJoint(position, spring, damper);
}
}
else if (showDebug)
{
Debug.Log(base.name + " There is nothing set within the joint var ");
}
}
else
{
velocity.SetValue(0f);
}
oldpower = num3;
}
private void SafeSetValue(NodeOutput output, float value)
{
output?.SetValue(value);
}
private void Update()
{
distance.SetValue((transform1.position - transform2.position).magnitude);
}
public override void Process()
{
output.SetValue(0f - input.value);
}
private void FixedUpdate()
{
if (ReplayRecorder.isPlaying || NetGame.isClient)
{
return;
}
disableMotorTime -= Time.fixedDeltaTime;
float num = position;
float num2 = direction;
if (mode == ServoMode.Position)
{
float num3 = Mathf.Lerp(minValue, maxValue, (!signedInput) ? input.value : ((input.value + 1f) / 2f));
speed = Mathf.MoveTowards(speed, Mathf.Sign(num3 - num) * maxSpeed, maxAcceleration * Time.fixedDeltaTime);
position += speed * power.value * Time.fixedDeltaTime;
if (speed < 0f && position < num3 && num >= num3)
{
position = num3;
}
if (speed > 0f && position > num3 && num <= num3)
{
position = num3;
}
direction = Mathf.Sign(position - num);
if (direction * num2 < 0f)
{
disableMotorTime = reverseDelay;
}
motor.SetValue((power.value > 0f && disableMotorTime <= 0f && Mathf.Abs(num - num3) >= tensionDist) ? 1 : 0);
}
else
{
if (speed * input.value < 0f)
{
speed = 0f;
}
speed = Mathf.MoveTowards(speed, input.value * maxSpeed, maxAcceleration * Time.fixedDeltaTime);
position += speed * power.value * Time.fixedDeltaTime;
direction = Mathf.Sign(position - num);
if (direction * num2 < 0f)
{
disableMotorTime = reverseDelay;
}
if (mode == ServoMode.Speed)
{
if (reachedEnd == -1f && input.value > 0f)
{
reachedEnd = 0f;
}
else if (reachedEnd == 1f && input.value < 0f)
{
reachedEnd = 0f;
}
else if (position < minValue + tensionDist && input.value < 0f)
{
reachedEnd = -1f;
}
else if (position > maxValue - tensionDist && input.value > 0f)
{
reachedEnd = 1f;
}
}
motor.SetValue((power.value > 0f && disableMotorTime <= 0f && reachedEnd == 0f && input.value != 0f) ? 1 : 0);
}
if (num != position)
{
velocity.SetValue(Mathf.Clamp01(Mathf.Abs(position - num) / Time.fixedDeltaTime / maxSpeed));
if (isKinematic)
{
if (mode != ServoMode.SpeedIgnoreLimit)
{
position = Mathf.Clamp(position, minValue, maxValue);
}
SetStatic(position);
}
else
{
actualPosition = GetActualPosition();
position = Mathf.Clamp(position, actualPosition - tensionDist, actualPosition + tensionDist);
float spring = maxForce / tensionDist * power.value;
float damper = maxForce / maxSpeed * power.value;
SetJoint(position, spring, damper);
}
}
else
{
velocity.SetValue(0f);
}
}
private void OnCollisionEnter(Collision collision)
{
output.SetValue(1f);
}
public override void Process()
{
float num = 0f;
switch (operation)
{
case SignalBoolOperation.And:
{
num = 1f;
for (int n = 0; n < inputs.Length; n++)
{
if (Mathf.Abs(inputs[n].value) < 0.5f)
{
num = 0f;
}
}
break;
}
case SignalBoolOperation.Or:
{
num = 0f;
for (int j = 0; j < inputs.Length; j++)
{
if (Mathf.Abs(inputs[j].value) >= 0.5f)
{
num = 1f;
}
}
break;
}
case SignalBoolOperation.Xor:
{
num = 0f;
for (int l = 0; l < inputs.Length; l++)
{
if (Mathf.Abs(inputs[l].value) >= 0.5f)
{
num = 1f - num;
}
}
break;
}
case SignalBoolOperation.Sum:
{
num = 0f;
for (int num2 = 0; num2 < inputs.Length; num2++)
{
num += inputs[num2].value;
}
break;
}
case SignalBoolOperation.Mul:
{
num = 1f;
for (int m = 0; m < inputs.Length; m++)
{
num *= inputs[m].value;
}
break;
}
case SignalBoolOperation.Max:
{
num = float.NegativeInfinity;
for (int k = 0; k < inputs.Length; k++)
{
num = Mathf.Max(num, inputs[k].value);
}
break;
}
case SignalBoolOperation.Min:
{
num = float.PositiveInfinity;
for (int i = 0; i < inputs.Length; i++)
{
num = Mathf.Min(num, inputs[i].value);
}
break;
}
}
if (invert)
{
output.SetValue(1f - num);
}
else
{
output.SetValue(num);
}
}
private void FixedUpdate()
{
if (joint == null)
{
return;
}
float jointAngle = GetJointAngle();
bool flag = GrabManager.IsGrabbedAny(joint.gameObject);
if (!grabbed && flag)
{
grabbedInGear = gear;
}
grabbed = flag;
if (grabbed)
{
if (jointAngle <= (reverseAngle + neutralAngle) / 2f)
{
gear = -1;
}
else if (jointAngle <= (neutralAngle + firstAngle) / 2f)
{
gear = 0;
}
else if (jointAngle <= (firstAngle + secondAngle) / 2f)
{
gear = 1;
}
else
{
gear = 2;
}
JointLimits limits = joint.limits;
limits.min = reverseAngle;
if (grabbedInGear < 1)
{
if (gear == 2)
{
gear = 1;
}
limits.max = firstAngle;
}
else
{
limits.max = secondAngle;
}
joint.SetLimits(limits);
if (steeringWheel != null)
{
JointSpring spring = steeringWheel.spring;
spring.spring = ((gear != 2) ? centeringSpring1st : centeringSpring2st);
steeringWheel.spring = spring;
}
}
float value = 0f;
JointSpring spring2 = joint.spring;
switch (gear)
{
case -1:
spring2.targetPosition = reverseAngle;
value = reverseValue;
break;
case 0:
spring2.targetPosition = neutralAngle;
value = 0f;
break;
case 1:
spring2.targetPosition = firstAngle;
value = firstValue;
break;
case 2:
spring2.targetPosition = secondAngle;
value = secondValue;
break;
}
joint.SetSpring(spring2);
output.SetValue(value);
}
