// Don't reset character controller values to hardcoded "0.9 center, 1.8 height" values while Gulliver is active.
// This code is a copy&paste of the original implementation; only the "center" and "targetHeight" calculations
// are multiplied by the Player's scale
public override void UpdateCharacterControllerSizeAndCenter()
{
if (!GulliverMod.IsEnabled)
{
base.UpdateCharacterControllerSizeAndCenter();
}
else
{
float scale = transform.localScale.x;
Vector3 center = m_CharacterController.center;
m_CharacterControllerLastOffset = center;
float targetHeight;
if (m_SwimController.IsActive())
{
center.y = 1.35f * scale;
targetHeight = 0.9f * scale;
}
else if (m_FPPController.IsDuck())
{
center.y = 0.65f * scale;
targetHeight = 1.3f * scale;
}
else
{
center.y = 0.9f * scale;
targetHeight = 1.8f * scale;
}
center.y = m_CharacterController.center.y + (float)((center.y - (double)m_CharacterController.center.y) * Time.deltaTime * 2.0);
if (m_FPPController.IsActive() && !FreeHandsLadderController.Get().IsActive())
{
center.z = m_LookController.m_LookDev.y > -40f ? CJTools.Math.GetProportionalClamp(0.35f * scale, -0.35f * scale, m_LookController.m_LookDev.y, -40f, 80f) : 0.35f * scale;
}
m_CharacterController.height = m_CharacterController.height + (float)((targetHeight - (double)m_CharacterController.height) * Time.deltaTime * 2.0);
m_CharacterController.center = center;
m_CharacterControllerDelta = center - m_CharacterControllerLastOffset;
m_CharacterControllerDelta.y = 0f;
}
}
private void UpdateWantedSpeed()
{
if (!this.IsActive() || (FreeHandsLadderController.Get().IsActive() && !this.m_JumpInProgress))
{
this.m_WantedSpeed.Reset();
this.m_SlidingSpeedSoft.Reset();
this.m_SlideDir = Vector3.zero;
this.m_CurentMoveSpeed = 0f;
this.m_CurrentMoveSpeed = MoveSpeed.Idle;
return;
}
Vector2 vector = new Vector2(this.m_Inputs.m_Horizontal, this.m_Inputs.m_Vertical);
if (vector.sqrMagnitude > 1f)
{
vector.Normalize();
}
bool flag = (this.m_CollisionFlags & CollisionFlags.Below) == CollisionFlags.None;
bool flag2 = !flag && (this.m_CollisionFlagsAddSpeed & CollisionFlags.Below) == CollisionFlags.None;
bool flag3 = this.m_Inputs.m_Sprint;
float num = 0f;
this.m_CurrentMoveSpeed = MoveSpeed.Idle;
bool flag4 = this.m_Player && this.m_Player.GetMovesBlocked();
if (this.m_RunDepletedStamina)
{
if (flag3)
{
flag3 = false;
}
else
{
this.m_RunDepletedStamina = false;
}
}
if (BowController.Get().m_MaxAim)
{
flag3 = false;
}
if (flag3 && this.m_RunBlocked)
{
flag3 = false;
}
if (!flag4 && vector.magnitude > 0.5f)
{
if (flag3)
{
if (vector.y < -0.5f)
{
num = this.m_BackwardWalkSpeed;
this.m_CurrentMoveSpeed = MoveSpeed.Walk;
}
else
{
num = this.m_RunSpeed;
this.m_CurrentMoveSpeed = MoveSpeed.Run;
}
}
else if (vector.magnitude > 0.5f)
{
num = ((vector.y >= 0f) ? this.m_WalkSpeed : this.m_BackwardWalkSpeed);
this.m_CurrentMoveSpeed = MoveSpeed.Walk;
}
if (this.m_Player && this.m_Player.IsStaminaDepleted())
{
num = this.m_WalkSpeed;
this.m_CurrentMoveSpeed = MoveSpeed.Walk;
if (flag3)
{
this.m_RunDepletedStamina = true;
}
}
}
if (this.m_Duck)
{
num *= this.m_DuckSpeedMul;
}
Vector3 vector2 = this.m_CharacterController.transform.InverseTransformVector(this.m_WantedSpeed.target);
vector2.x = vector.x * num;
vector2.z = vector.y * num;
if (this.m_Dodge)
{
num = 10f;
if (this.m_DodgeDirection != Direction.Backward)
{
vector2.x = ((this.m_DodgeDirection == Direction.Right) ? 1f : -1f);
vector2.z = 0f;
}
else
{
vector2.x = 0f;
vector2.z = -1f;
}
if (Time.time - this.m_DodgeStartTime > 0.15f)
{
this.m_Dodge = false;
}
}
float y = vector2.y;
vector2.y = 0f;
vector2.Normalize();
vector2 *= num;
vector2.y = y;
if (InventoryBackpack.Get().IsMaxOverload())
{
vector2 *= this.m_MaxOverloadSpeedMul;
}
bool flag5 = this.m_TimeInAir < 0.5f;
if (flag5)
{
this.m_WantedSpeed.target = this.m_CharacterController.transform.TransformVector(vector2);
}
if (flag2)
{
this.m_SlideDir = this.m_AdditionalSpeed.normalized;
}
else if (!flag)
{
this.m_SlideDir = Vector3.zero;
}
if (flag || (!this.m_SlideDir.IsZero() && flag2))
{
Vector3 vector3 = this.m_WantedSpeed.target;
vector3.y = 0f;
Vector3 slideDir = this.m_SlideDir;
slideDir.y = 0f;
if (Vector3.Dot(vector3, slideDir) < 0f)
{
Vector3 normalized = Vector3.Cross(slideDir, Vector3.up).normalized;
vector3 = Vector3.Dot(vector3, normalized) * normalized;
this.m_WantedSpeed.target.x = vector3.x;
this.m_WantedSpeed.target.z = vector3.z;
}
}
if (Time.timeScale > 0f)
{
if (this.m_SlideDir.IsZero())
{
this.m_SlidingSpeedSoft.target = Vector3.zero;
this.m_SlidingSpeedSoft.omega = this.m_SlideDeceleration;
}
else
{
float proportionalClamp = CJTools.Math.GetProportionalClamp(0f, 1f, this.m_SlideAngle, this.m_CharacterController.slopeLimit, this.m_CharacterController.slopeLimit + 20f);
this.m_SlidingSpeedSoft.target = this.m_SlideDir * this.m_SlideMaxSpeed * Mathf.Lerp(0.2f, 1f, proportionalClamp);
this.m_SlidingSpeedSoft.omega = Mathf.Lerp(this.m_SlideAcceleration * 0.1f, this.m_SlideAcceleration, proportionalClamp);
}
if (!flag5)
{
this.m_WantedSpeed.target = this.m_WantedSpeed.target - this.m_SlidingSpeedSoft;
}
this.m_SlidingSpeedSoft.Update(Time.deltaTime / Time.timeScale);
this.m_WantedSpeed.target = this.m_WantedSpeed.target + this.m_SlidingSpeedSoft;
}
if (this.m_Player.m_UseGravity)
{
this.m_WantedSpeed.target = this.m_WantedSpeed.target + Physics.gravity * Time.deltaTime;
}
else
{
this.m_WantedSpeed.current.x = (this.m_WantedSpeed.target.x = 0f);
this.m_WantedSpeed.current.y = (this.m_WantedSpeed.target.y = 0f);
this.m_WantedSpeed.current.z = (this.m_WantedSpeed.target.z = 0f);
}
if (this.m_WantedSpeed.target.y < -10f)
{
this.m_WantedSpeed.target.y = -10f;
}
Vector3 b = Vector3.zero;
if (!this.m_Player.GetMovesBlocked() && this.m_CharacterController.detectCollisions && !this.m_SkipCompensation && !FreeHandsLadderController.Get().IsActive())
{
b = -this.m_CharacterController.transform.TransformVector(this.m_Player.m_CharacterControllerDelta);
}
b.y = 0f;
if ((this.m_CollisionFlags & CollisionFlags.Below) == CollisionFlags.None)
{
this.m_WantedSpeed.omega = this.m_AccelerationInAir;
this.m_WantedPos.omega = this.m_AccelerationInAir;
}
else if (this.m_Dodge)
{
this.m_WantedSpeed.omega = this.m_DodgeAcceleration;
this.m_WantedPos.omega = this.m_DodgeAcceleration;
}
else
{
this.m_WantedSpeed.omega = this.m_Acceleration;
this.m_WantedPos.omega = this.m_PositionAcceleration;
}
if (Time.timeScale > 0f)
{
this.m_WantedSpeed.Update(Time.deltaTime / Time.timeScale);
}
this.m_CurentMoveSpeed = this.m_WantedSpeed.current.To2D().magnitude;
this.m_CollisionFlagsAddSpeed = CollisionFlags.None;
this.m_SlideAngle = 0f;
this.m_AdditionalSpeed = Vector3.zero;
this.m_CollisionFlags = this.m_CharacterController.Move(this.m_Player.m_SpeedMul * this.m_WantedSpeed.current * Time.deltaTime, false);
Vector2.zero.Set(this.m_WantedSpeed.current.x, this.m_WantedSpeed.current.z);
if ((this.m_CollisionFlags & CollisionFlags.Sides) != CollisionFlags.None)
{
this.m_LastSideCollisionTime = Time.time;
}
if ((this.m_CollisionFlags & CollisionFlags.Below) != CollisionFlags.None && (this.m_LastCollisionFlags & CollisionFlags.Below) == CollisionFlags.None)
{
this.m_Player.OnLanding(this.m_CharacterController.velocity);
this.m_JumpInProgress = false;
}
if ((this.m_CollisionFlags & CollisionFlags.Below) != CollisionFlags.None)
{
this.m_TimeInAir = 0f;
}
else
{
this.m_TimeInAir += Time.deltaTime;
}
this.m_LastCollisionFlags = this.m_CollisionFlags;
this.m_SkipCompensation = false;
this.m_WantedPos.current = base.transform.position;
this.m_WantedPos.target = this.m_CharacterController.transform.position + b;
if (Time.timeScale > 0f)
{
this.m_WantedPos.Update(Time.deltaTime / Time.timeScale);
}
base.transform.position = this.m_WantedPos.current;
}
public override void OnInputAction(InputActionData action_data)
{
base.OnInputAction(action_data);
if (LoadingScreen.Get().m_Active)
{
return;
}
if (InventoryBackpack.Get().IsMaxOverload())
{
return;
}
if (action_data.m_Action == InputsManager.InputAction.Jump && HUDMovie.Get().GetMovieType() == MovieType.None)
{
bool flag = FreeHandsLadderController.Get().IsActive();
if ((this.m_CollisionFlags & CollisionFlags.Below) > CollisionFlags.None || flag)
{
bool flag2 = InputsManager.Get().IsActionActive(InputsManager.InputAction.DodgeLeft);
bool flag3 = InputsManager.Get().IsActionActive(InputsManager.InputAction.DodgeRight);
bool flag4 = InputsManager.Get().IsActionActive(InputsManager.InputAction.DodgeForward);
bool flag5 = InputsManager.Get().IsActionActive(InputsManager.InputAction.DodgeBackward);
if (!flag && flag2 && !flag4)
{
this.Dodge(Direction.Left);
return;
}
if (!flag && flag3 && !flag4)
{
this.Dodge(Direction.Right);
return;
}
if (!flag && flag5)
{
this.Dodge(Direction.Backward);
return;
}
this.Jump();
return;
}
}
else if (action_data.m_Action == InputsManager.InputAction.Duck && GreenHellGame.Instance.m_Settings.m_ToggleCrouch)
{
if (this.CanCrouch())
{
this.m_Inputs.m_Duck = !this.m_Inputs.m_Duck;
this.m_Inputs.m_Sprint = false;
return;
}
}
else if (action_data.m_Action == InputsManager.InputAction.Duck && !GreenHellGame.Instance.m_Settings.m_ToggleCrouch)
{
if (this.CanCrouch())
{
this.m_Inputs.m_Duck = true;
this.m_Inputs.m_Sprint = false;
return;
}
}
else
{
if (action_data.m_Action == InputsManager.InputAction.DuckStop && !GreenHellGame.Instance.m_Settings.m_ToggleCrouch)
{
this.m_Inputs.m_Duck = false;
return;
}
if (action_data.m_Action == InputsManager.InputAction.Sprint && (GreenHellGame.Instance.m_Settings.m_ToggleRunOption == GameSettings.ToggleRunOption.Yes || GreenHellGame.Instance.m_Settings.m_ToggleRunOption == GameSettings.ToggleRunOption.Always))
{
this.m_Inputs.m_Sprint = !this.m_Inputs.m_Sprint;
this.m_Inputs.m_Duck = false;
}
}
}
