private void Update()
{
if (input.value >= threshold && GrabManager.IsGrabbedAny(item))
{
GrabManager.Release(item, blockTime);
}
}
private void FixedUpdate()
{
if (!fixInPlace || !(fixJoint == null) || !(bodyToFix != null))
{
return;
}
bool flag = false;
foreach (Rigidbody contactMagnetBody in contactMagnetBodies)
{
if (bodyToFix == contactMagnetBody && !GrabManager.IsGrabbedAny(contactMagnetBody.gameObject))
{
flag = true;
}
}
if (flag)
{
fixTimer += Time.fixedDeltaTime;
if (fixTimer >= timeToFix)
{
fixJoint = bodyToFix.gameObject.AddComponent <FixedJoint>();
fixJoint.connectedBody = Body;
CalculateMagnetActive();
fixTimer = 0f;
}
}
else
{
fixTimer = 0f;
}
}
public void OnFryMeToTheMoonAchievementCheck(GameObject objectToBeGrabbing)
{
if (objectToBeGrabbing != null && GrabManager.IsGrabbedAny(objectToBeGrabbing))
{
Debug.Log("FRY ME TO THE MOON ACHIEVEMENT COMPLETE");
StatsAndAchievements.UnlockAchievement(Achievement.ACH_HALLOWEEN_FRY_ME_TO_THE_MOON);
}
}
private void UpdateIdle()
{
if (GrabManager.IsGrabbedAny(windlass.gameObject))
{
SetState(CatapultState.Wind);
}
else if (windlassAngle != topWindlassAngle && GrabManager.IsGrabbedAny(release.gameObject))
{
SetState(CatapultState.Trigger);
}
}
private void UpdateFire()
{
if (fired)
{
if (!GrabManager.IsGrabbedAny(release.gameObject))
{
if (timeFired > 1f)
{
SetState(CatapultState.Idle);
return;
}
PullDownTrigger();
timeFired += Time.fixedDeltaTime;
}
else
{
timeFired = 0f;
}
WriteArm();
WriteWindlass();
return;
}
timeFired = 0f;
bool flag = GrabManager.IsGrabbedAny(arm.gameObject) || GroundManager.IsStandingAny(arm.gameObject);
speed += acceleration * Time.fixedDeltaTime * ((!flag) ? 1f : 0.9f);
windlassAngle -= speed * Time.fixedDeltaTime;
if (windlassAngle > topWindlassAngle)
{
currentTooth = (windlassAngle = topWindlassAngle);
}
WriteArm();
WriteWindlass();
if (windlassAngle != topWindlassAngle)
{
return;
}
for (int i = 0; i < Human.all.Count; i++)
{
Human human = Human.all[i];
if (human.ragdoll.partLeftHand.sensor.grabBody == arm.GetComponent <Rigidbody>())
{
human.ragdoll.partLeftHand.sensor.ReleaseGrab(0.1f);
}
if (human.ragdoll.partRightHand.sensor.grabBody == arm.GetComponent <Rigidbody>())
{
human.ragdoll.partRightHand.sensor.ReleaseGrab(0.1f);
}
human.ragdoll.ReleaseHeavyArms();
}
fired = true;
}
private void FixedUpdate()
{
if (parentBody == null || !connectable)
{
return;
}
bool flag = GrabManager.IsGrabbedAny(parentBody.gameObject);
if (flag && connectedPipe == null)
{
PipePort pipePort = Scan();
if (pipePort != null && pipePort != ignorePipe)
{
ConnectPipe(pipePort);
return;
}
}
if (!flag)
{
ignorePipe = null;
}
if (!(connectedPipe != null) || !isMaster)
{
return;
}
Vector3 position = base.transform.position;
if (position.y < -40f && springIn != null)
{
DisconnectPipe();
return;
}
if (breakableIn > 0f)
{
ApplyJointForce(loose: false, Apply: false);
breakableIn -= Time.fixedDeltaTime;
return;
}
bool loose = flag || (connectedPipe.parentBody != null && GrabManager.IsGrabbedAny(connectedPipe.parentBody.gameObject));
ApplyJointForce(loose, Apply: false);
float magnitude = (base.transform.position - connectedPipe.transform.position).magnitude;
if (springIn != null && magnitude > breakTreshold)
{
DisconnectPipe();
}
}
public void OnTriggerStay(Collider other)
{
Rigidbody componentInParent = other.GetComponentInParent <Rigidbody>();
if (componentInParent == null || componentInParent.isKinematic || bodiesAffected.Contains(componentInParent))
{
return;
}
bodiesAffected.Add(componentInParent);
worldWind = base.transform.TransformVector(wind) * input.value;
normal = worldWind.normalized;
D = Vector3.Dot(base.transform.position, normal);
if (!(worldWind == Vector3.zero))
{
float num = Vector3.Dot(componentInParent.worldCenterOfMass, normal) - D;
Vector3 vector = componentInParent.worldCenterOfMass - num * normal - base.transform.position;
float num2 = Mathf.InverseLerp(coreRadius + radialFalloff, coreRadius, vector.magnitude);
float num3 = Mathf.InverseLerp(dist + distFalloff, dist, num);
Human component = componentInParent.GetComponent <Human>();
float num4 = componentInParent.mass;
if (component != null)
{
num4 = component.mass / (float)component.rigidbodies.Length;
}
float d = num4;
Vector3 vector2 = (worldWind - componentInParent.velocity).magnitude * (worldWind - componentInParent.velocity) * cDrag * d;
if (vector.magnitude > 0.1f)
{
vector2 += (0f - componentInParent.mass) * vector * centeringSpring;
vector2 += componentInParent.mass * Vector3.Project(-componentInParent.velocity, vector) * centeringDamper;
}
vector2 *= num2 * num3;
vector2 = Vector3.ClampMagnitude(vector2, num4 * maxAcceleration);
if (vector2.magnitude / num4 > 10f && GrabManager.IsGrabbedAny(componentInParent.gameObject))
{
GrabManager.Release(componentInParent.gameObject, 0.2f);
}
componentInParent.AddForce(vector2);
Debug.DrawRay(componentInParent.worldCenterOfMass, vector2 / 10f / componentInParent.mass, Color.cyan, 0.1f);
if (component != null)
{
componentInParent.AddForce(component.controls.walkDirection * humanFlyForce);
}
}
}
private void Update()
{
if (ReplayRecorder.isPlaying || NetGame.isClient)
{
return;
}
if (gearbox.gear != currentGear)
{
SetGet(gearbox.gear);
}
if (GrabManager.IsGrabbedAny(lever.gameObject) != leverGrabbed)
{
if (!leverGrabbed)
{
GrabLever();
}
else
{
ReleaseLever();
}
}
}
public void Respawn()
{
if (ReplayRecorder.isPlaying || NetGame.isClient || GrabManager.IsGrabbedAny(base.gameObject))
{
return;
}
RestartableRigid component = GetComponent <RestartableRigid>();
if (component != null)
{
component.Reset(Vector3.up * respawnHeight);
return;
}
base.transform.position = startPos + Vector3.up * respawnHeight;
base.transform.rotation = startRot;
Rigidbody component2 = GetComponent <Rigidbody>();
if (component2 != null)
{
component2.velocity = Vector3.zero;
component2.angularVelocity = Vector3.zero;
}
}
private void FixedUpdate()
{
if (!topGrabbable && GrabManager.IsGrabbedAny(topTrack.gameObject))
{
GrabManager.Release(topTrack.gameObject, 1f);
}
if (!bottomGrabbable && GrabManager.IsGrabbedAny(bottomTrack.gameObject))
{
GrabManager.Release(bottomTrack.gameObject, 1f);
}
if (!startGrabbable && GrabManager.IsGrabbedAny(startTrack.gameObject))
{
GrabManager.Release(startTrack.gameObject, 1f);
}
if (!endGrabbable && GrabManager.IsGrabbedAny(endTrack.gameObject))
{
GrabManager.Release(endTrack.gameObject, 1f);
}
if (!ReplayRecorder.isPlaying && !NetGame.isClient && input.value != 0f && !(topTrack == null))
{
AdvanceArrays(input.value * speed * Time.fixedDeltaTime);
}
}
private void UpdateWind()
{
if (!GrabManager.IsGrabbedAny(windlass.gameObject))
{
if (timeReleased > 1f)
{
SetState(CatapultState.Idle);
return;
}
timeReleased += Time.fixedDeltaTime;
}
else
{
timeReleased = 0f;
}
if (armed)
{
WriteWindlass();
WriteArm();
return;
}
ReadWindlass();
if (windlassAngle < bottomWindlassAngle)
{
SetArmed(value: true);
ratchetSound.PlayOneShot();
}
else if (windlassAngle < currentTooth - toothStep)
{
float pitch = 0.5f + 0.5f * Mathf.InverseLerp(topWindlassAngle, bottomWindlassAngle, windlassAngle);
ratchetSound.PlayOneShot(1f, pitch);
currentTooth -= toothStep;
}
WriteArm();
PullBackWindlass();
PullDownTrigger();
}
private void UpdateTrigger()
{
if (!GrabManager.IsGrabbedAny(release.gameObject))
{
SetState(CatapultState.Idle);
}
else
{
if (!(release.angle < -5f))
{
return;
}
shoot = true;
speed = 0f;
for (int i = 0; i < Human.all.Count; i++)
{
Human human = Human.all[i];
bool flag = human.groundManager.IsStanding(arm.gameObject);
if (human.ragdoll.partLeftHand.sensor.grabBody == release.GetComponent <Rigidbody>() && (flag || human.ragdoll.partRightHand.sensor.grabBody == arm.GetComponent <Rigidbody>()))
{
human.ragdoll.partLeftHand.sensor.ReleaseGrab(1f);
}
if (human.ragdoll.partRightHand.sensor.grabBody == release.GetComponent <Rigidbody>() && (flag || human.ragdoll.partLeftHand.sensor.grabBody == arm.GetComponent <Rigidbody>()))
{
human.ragdoll.partRightHand.sensor.ReleaseGrab(1f);
}
human.ragdoll.ToggleHeavyArms(human.ragdoll.partLeftHand.sensor.grabBody == arm.GetComponent <Rigidbody>(), human.ragdoll.partRightHand.sensor.grabBody == arm.GetComponent <Rigidbody>());
if (flag)
{
StatsAndAchievements.UnlockAchievement(Achievement.ACH_SIEGE_HUMAN_CANNON);
}
}
SetState(CatapultState.Fire);
releaseSound.PlayOneShot();
}
}
private bool CalculateGrabbed()
{
return(GrabManager.IsGrabbedAny(buttonTransform.gameObject));
}
private void FixedUpdate()
{
if (ReplayRecorder.isPlaying || NetGame.isClient)
{
return;
}
bool flag = false;
for (int i = 0; i < grablist.Length; i++)
{
if (GrabManager.IsGrabbedAny(grablist[i]))
{
flag = true;
}
}
if (flag && connectedSocket == null)
{
HoseSocket hoseSocket = HoseSocket.Scan(alignmentTransform.position);
if (hoseSocket != null && hoseSocket != ignoreSocketConnect)
{
if (Connect(hoseSocket))
{
canBreak = false;
breakableIn = breakDelay;
return;
}
Collider[] array = Physics.OverlapSphere(base.transform.position, 5f);
for (int j = 0; j < array.Length; j++)
{
Rigidbody componentInParent = array[j].GetComponentInParent <Rigidbody>();
if (componentInParent != null && !componentInParent.isKinematic)
{
componentInParent.AddExplosionForce(20000f, base.transform.position, 5f);
Human componentInParent2 = componentInParent.GetComponentInParent <Human>();
if (componentInParent2 != null)
{
componentInParent2.MakeUnconscious();
}
}
}
SendPlug(PlugEventType.Short);
}
}
if (!flag)
{
ignoreSocketConnect = null;
canBreak = true;
}
if (breakableIn > 0f)
{
breakableIn -= Time.fixedDeltaTime;
}
else if (connectedSocket != null)
{
springIn.spring = ((!flag) ? spring : (spring / 2f));
springOut.spring = ((!flag) ? spring : (spring / 2f));
float num = (alignmentTransform.position - alignmentTransform.forward * dispacementTolerance - connectedSocket.transform.position).magnitude - dispacementTolerance;
if (springIn != null && springOut != null && num > breakTreshold)
{
Disconnect();
}
}
}
public void FixedUpdate()
{
if (ReplayRecorder.isPlaying || NetGame.isClient)
{
return;
}
bool flag = GrabManager.IsGrabbedAny(release.body.gameObject);
bool flag2 = GrabManager.IsGrabbedAny(ratchet.body.gameObject);
if (!firing && flag && !flag2 && release.GetValue() > release.centerValue && catapultAngle < arm.maxValue - 10f)
{
hasHuman = false;
for (int i = 0; i < Human.all.Count; i++)
{
Human human = Human.all[i];
bool flag3 = human.groundManager.IsStanding(arm.body.gameObject);
bool flag4 = human.grabManager.IsGrabbed(arm.body.gameObject);
if (flag3 || flag4)
{
human.ReleaseGrab(release.body.gameObject);
hasHuman = true;
human.ragdoll.ToggleHeavyArms(human.ragdoll.partLeftHand.sensor.grabBody == arm.body.GetComponent <Rigidbody>(), human.ragdoll.partRightHand.sensor.grabBody == arm.body.GetComponent <Rigidbody>());
}
if (flag3)
{
StatsAndAchievements.UnlockAchievement(Achievement.ACH_SIEGE_HUMAN_CANNON);
}
}
firing = true;
fireTime = 0f;
fireStart = catapultAngle;
if (releaseSound != null)
{
releaseSound.PlayOneShot();
}
ratchet.release = true;
release.SetTarget(release.maxValue);
}
if (firing && catapultAngle == arm.maxValue)
{
firing = false;
arm.anchor.GetComponent <Rigidbody>().isKinematic = false;
ratchet.release = false;
release.SetTarget(release.minValue);
releaseArmIn = 0.12f;
}
if (releaseArmIn > 0f)
{
releaseArmIn -= Time.fixedDeltaTime;
if (releaseArmIn <= 0f)
{
for (int j = 0; j < Human.all.Count; j++)
{
Human human2 = Human.all[j];
human2.ReleaseGrab(arm.body.gameObject, 0.1f);
human2.ragdoll.ReleaseHeavyArms();
}
}
}
if (firing)
{
fireTime += Time.fixedDeltaTime;
catapultAngle = Mathf.Clamp(fireStart + initialAcceleration * fireTime * fireTime / 2f + accelerationAcceleration * fireTime * fireTime * fireTime / 3f, arm.minValue, arm.maxValue);
arm.SetTarget(catapultAngle);
ratchet.SetValue(Mathf.Lerp(ratchet.minValue, ratchet.maxValue, Mathf.InverseLerp(arm.maxValue, arm.minValue, catapultAngle)));
}
else
{
catapultAngle = Mathf.Lerp(arm.maxValue, arm.minValue, Mathf.InverseLerp(ratchet.minValue, ratchet.maxValue, ratchet.GetValue()));
arm.SetTarget(catapultAngle);
}
float num = 1f;
if (firing)
{
num = ((!hasHuman) ? 1.5f : 2f);
}
else if (GrabManager.IsGrabbedAny(base.gameObject) && !flag && !flag2)
{
num = 0.2f;
}
Rigidbody component = GetComponent <Rigidbody>();
Rigidbody component2 = arm.body.GetComponent <Rigidbody>();
if (component.mass != num * initialMass)
{
component.mass = num * initialMass;
component2.mass = num * armMass;
}
}
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);
}
