private void OnEnable()
{
human = GetComponent <Human>();
ragdoll = GetComponent <Ragdoll>();
ballRadius = GetComponent <SphereCollider>().radius;
grabManager = GetComponent <GrabManager>();
}
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 RemoveGrabber(GrabManager grabManager)
{
if (activeGrabbers.Contains(grabManager))
{
activeGrabbers.Remove(grabManager);
}
}
public void DespawnPlayer()
{
if (NetGame.netlog)
{
Debug.LogFormat("Destroying {0}", netId);
}
if (isLocalPlayer)
{
if (skin != null)
{
App.StopPlaytimeForItem(skin.workshopId);
}
MenuCameraEffects.instance.RemoveHuman(this);
Listener.instance.RemoveHuman(human);
if (App.state == AppSate.Customize)
{
Player0Device = controls.device;
}
}
host.RemovePlayer(this);
if (isLocalPlayer)
{
PlayerManager.instance.OnLocalPlayerRemoved(this);
}
if (base.gameObject != null)
{
GrabManager.Release(base.gameObject);
}
Object.Destroy(base.gameObject);
}
private void OnEnable()
{
thisTransform = base.transform;
thisBody = GetComponent <Rigidbody>();
grabManager = GetComponentInParent <GrabManager>();
groundManager = GetComponentInParent <GroundManager>();
human = GetComponentInParent <Human>();
}
protected override void OnDestroy()
{
base.OnDestroy();
if (base.gameObject != null)
{
GrabManager.Release(base.gameObject);
}
}
// Use this for initialization
void Start()
{
gameCam = Camera.main;
grabber = gameObject.GetComponent <GrabManager> ();
mouseman = this;
uiManager = gameObject.transform.parent.GetComponentInChildren <UIManager> ();
}
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);
}
}
public void OnRelease()
{
if (!NetGame.isClient)
{
screen.Hide();
}
GrabManager.Release(screen.gameObject, 0.3f);
}
protected override void Start()
{
base.Start();
m_crosshair = gameObject.GetComponentInChildren <GrabbableCrosshair>();
m_renderer = gameObject.GetComponent <Renderer>();
m_crosshairManager = FindObjectOfType <GrabManager>();
m_mpb = new MaterialPropertyBlock();
RefreshCrosshair();
}
public void OnGrab()
{
if (NetGame.isServer)
{
Human human = GrabManager.GrabbedBy(base.gameObject);
CSteamID cSteamID = (CSteamID)human.player.host.connection;
userId = cSteamID.m_SteamID;
}
}
private void OnEnable()
{
all.Add(this);
instance = this;
grabManager = GetComponent <GrabManager>();
groundManager = GetComponent <GroundManager>();
motionControl2 = GetComponent <HumanMotion2>();
controls = GetComponentInParent <HumanControls>();
}
public void OnGrabbed(GrabManager grabManager)
{
if (!activeGrabbers.Contains(grabManager))
{
activeGrabbers.Add(grabManager);
}
rigidBody.isKinematic = true;
rigidBody.useGravity = false;
}
private void UpdateIdle()
{
if (GrabManager.IsGrabbedAny(windlass.gameObject))
{
SetState(CatapultState.Wind);
}
else if (windlassAngle != topWindlassAngle && GrabManager.IsGrabbedAny(release.gameObject))
{
SetState(CatapultState.Trigger);
}
}
protected override void HandleGrabPointLetGo(GrabPointGrabFeature grabPoint)
{
base.HandleGrabPointLetGo(grabPoint);
if (grabPoint.Priority == GrabPointPriority.Primary)
{
InputController.Instance.UnregisterTriggerTriggeredNotify(grabPoint.Grabbable.ActiveGrabber.Hand, HandleTriggerTriggered);
}
activeGrabber = null;
}
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;
}
public void OnLetGo(GrabManager grabManager)
{
RemoveGrabber(grabManager);
if (activeGrabbers.Count == 0)
{
rigidBody.isKinematic = false;
rigidBody.useGravity = true;
rigidBody.velocity = grabManager.Velocity * throwSpeedMultiplier;
rigidBody.angularVelocity = grabManager.AngularVelocity;
}
}
public void OnTriggerEnter(Collider other)
{
if (doneMixing || other == null)
{
return;
}
bool flag = false;
for (int i = 0; i < items.Length; i++)
{
if (!other.gameObject.transform.IsChildOf(items[i].item.transform))
{
continue;
}
flag = true;
if (items[i].mixEffect == MixEffect.Destroy || (itemAdded[i] == 0 && items[i].mixEffect == MixEffect.DestroyFirst))
{
if (other.gameObject == items[i].item)
{
GrabManager.Release(other.gameObject);
SendDestroyIngredient(i, -1);
}
else
{
for (int j = 0; j < items[i].item.transform.childCount; j++)
{
Transform child = items[i].item.transform.GetChild(j);
if (other.gameObject.transform.IsChildOf(child))
{
GrabManager.Release(other.gameObject);
GrabManager.Release(child.gameObject);
SendDestroyIngredient(i, j);
break;
}
}
}
}
itemAdded[i]++;
items[i].itemAdded.Invoke();
if (itemAdded.All((int x) => x != 0))
{
allItemsHaveBeenAdded = true;
allItems.SetValue(1f);
}
break;
}
if (!flag)
{
badItemAdded.Invoke();
}
}
void Awake()
{
if (_instance != null)
{
Destroy(this.gameObject);
return;
}
Cursor.SetCursor(cursorsImage[0], Vector3.zero, CursorMode.ForceSoftware);
_instance = this;
_instance.Initialize();
DontDestroyOnLoad(_instance.gameObject);
}
protected virtual void Shatter(Vector3 contactPoint, Vector3 adjustedImpulse, float impactMagnitude, uint seed, uint netId)
{
renderer.enabled = false;
collider.enabled = false;
if (audio != null)
{
audio.Shatter(impactMagnitude, contactPoint);
}
if (audioSource != null)
{
audioSource.Shatter(impactMagnitude, contactPoint);
}
GrabManager.Release(base.gameObject);
}
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();
}
}
private void Start()
{
grabManager = GetComponent <GrabManager>();
rangedGrabDetector = GetComponent <RangedGrabDetector>();
InputController.Instance.RegisterGripTriggeredNotify(grabManager.Hand, HandleGrabTriggered);
InputController.Instance.RegisterGripCanceledNotify(grabManager.Hand, HandleGripLetGo);
if (flickActivated)
{
InputController.Instance.RegisterDeviceAngularVelocityNotify(grabManager.Hand, HandleAngularVelocityChange);
}
else
{
InputController.Instance.RegisterTriggerTriggeredNotify(grabManager.Hand, HandleTriggerTriggered);
}
}
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);
}
}
}
public void Respawn(Vector3 offset)
{
if (ReplayRecorder.isPlaying || NetGame.isClient)
{
return;
}
GrabManager.Release(base.gameObject);
Vector3 vector = startPos + offset;
Quaternion quaternion = startRot;
if (overrides != null)
{
RespawningBodyOverride respawningBodyOverride = null;
for (int i = 0; i < overrides.Count; i++)
{
if (overrides[i].checkpoint.number <= Game.instance.currentCheckpointNumber && (respawningBodyOverride == null || overrides[i].checkpoint.number > respawningBodyOverride.checkpoint.number))
{
respawningBodyOverride = overrides[i];
}
}
if (respawningBodyOverride != null)
{
vector = respawningBodyOverride.initialToNewLocationMatrtix.MultiplyPoint3x4(vector);
quaternion = respawningBodyOverride.initialToNewLocationRotation * quaternion;
}
}
mJustReset = 5;
mResetPosition = vector;
mResetRotation = quaternion;
base.transform.position = vector;
base.transform.rotation = quaternion;
if (syncLocalScale)
{
base.transform.localScale = startLocalScale;
}
UpdateVisibility();
if (m_respawnEvent != null)
{
m_respawnEvent.Invoke();
}
else
{
Debug.LogError("Null respawn event.", this);
}
}
// Start is called before the first frame update
void Start()
{
gui_day = go_gui_day.GetComponent <TextMeshProUGUI>();
sc_aura = go_aura.GetComponent <AuraDetection>();
sc_pc = go_player.GetComponent <PlayerController_Sonic3>();
sc_pool = GetComponent <ObjectPooler>();
sc_list = GetComponent <ShoppingListManager>();
sc_spawn = GetComponent <ItemSpawnManager>();
sc_customer = GetComponent <CustomerManager>();
sc_grab = GetComponent <GrabManager>();
go_canvas.SetActive(true);
sc_pool.FillPool();
SetMenu(MenuState.Start);
}
public void Grab(GrabPointGrabFeature grabbedPoint)
{
if (grabbedPoint.Priority == GrabPointPriority.Primary)
{
primaryGrabPoint = grabbedPoint;
primaryGrabManager = primaryGrabPoint.Grabbable.ActiveGrabber;
onWeaponGrabPointGrabbed?.Invoke(primaryGrabPoint);
}
else
{
secondaryGrabPoint = grabbedPoint;
secondaryGrabManager = secondaryGrabPoint.Grabbable.ActiveGrabber;
onWeaponGrabPointGrabbed?.Invoke(secondaryGrabPoint);
}
isGrabbed = true;
}
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();
}
}
}
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);
}
}
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;
}
}
