// Token: 0x06000D3F RID: 3391 RVA: 0x0005E99C File Offset: 0x0005CB9C
private void RandomizeWaypoint(bool canHook)
{
Vector2 vector = UnityEngine.Random.insideUnitCircle * this.m_swimRange;
this.m_waypoint = this.m_spawnPoint + new Vector3(vector.x, 0f, vector.y);
this.m_waypointFF = null;
if (canHook)
{
FishingFloat fishingFloat = this.FindFloat();
if (fishingFloat)
{
this.m_waypointFF = fishingFloat;
this.m_waypoint = fishingFloat.transform.position + Vector3.down;
}
}
float pointDepth = this.GetPointDepth(this.m_waypoint);
if (pointDepth < this.m_minDepth)
{
return;
}
Vector3 p = (this.m_waypoint + base.transform.position) * 0.5f;
if (this.GetPointDepth(p) < this.m_minDepth)
{
return;
}
float max = Mathf.Min(this.m_maxDepth, pointDepth - this.m_height);
float waterLevel = WaterVolume.GetWaterLevel(this.m_waypoint, 1f);
this.m_waypoint.y = waterLevel - UnityEngine.Random.Range(this.m_minDepth, max);
this.m_haveWaypoint = true;
this.m_swimTimer = UnityEngine.Random.Range(this.m_wpDurationMin, this.m_wpDurationMax);
}
protected virtual void FixedUpdate()
{
if (water != null && voxels.Length > 0)
{
Vector3 forceAtSingleVoxel = GetBuoyancyForce() / voxels.Length;
Bounds bounds = collider.bounds;
float voxelHeight = bounds.size.y * normalizedVoxelSize;
for (int i = 0; i < voxels.Length; i++)
{
Vector3 worldPoint = transform.TransformPoint(voxels[i]);
float waterLevel = water.GetWaterLevel(worldPoint);
float deepLevel = waterLevel - worldPoint.y + (voxelHeight / 2f); // How deep is the voxel
float submergedFactor = Mathf.Clamp(deepLevel / voxelHeight, 0f, 1f); // 0 - voxel is fully out of the water, 1 - voxel is fully submerged
percentSubmerged += submergedFactor;
Vector3 surfaceNormal = water.GetSurfaceNormal(worldPoint);
Quaternion surfaceRotation = Quaternion.FromToRotation(water.transform.up, surfaceNormal);
surfaceRotation = Quaternion.Slerp(surfaceRotation, Quaternion.identity, submergedFactor);
Vector3 finalVoxelForce = surfaceRotation * (forceAtSingleVoxel * submergedFactor);
rigidbody.AddForceAtPosition(finalVoxelForce, worldPoint);
Debug.DrawLine(worldPoint, worldPoint + finalVoxelForce.normalized, Color.blue);
}
percentSubmerged /= voxels.Length; // 0 - object is fully out of the water, 1 - object is fully submerged
rigidbody.drag = Mathf.Lerp(initialDrag, dragInWater, percentSubmerged);
rigidbody.angularDrag = Mathf.Lerp(initialAngularDrag, angularDragInWater, percentSubmerged);
}
}
// Token: 0x06000DF3 RID: 3571 RVA: 0x00063868 File Offset: 0x00061A68
private void FixedUpdate()
{
if (!this.m_nview.IsValid() || !this.m_nview.IsOwner())
{
return;
}
float waterLevel = WaterVolume.GetWaterLevel(base.transform.position, this.m_waveScale);
if (waterLevel > -100f)
{
Vector3 position = this.m_body.position;
float num = Mathf.Clamp((waterLevel - (position.y + this.m_floatOffset)) * this.m_movementSpeed * Time.fixedDeltaTime, -this.m_maxSpeed, this.m_maxSpeed);
position.y += num;
this.m_body.MovePosition(position);
}
else
{
Vector3 position2 = this.m_body.position;
position2.y = 0f;
this.m_body.MovePosition(Vector3.MoveTowards(this.m_body.position, position2, Time.deltaTime));
}
if (this.m_animator.GetCurrentAnimatorStateInfo(0).IsTag("submerged"))
{
this.m_nview.Destroy();
}
}
// Token: 0x06000281 RID: 641 RVA: 0x00014330 File Offset: 0x00012530
private void LateUpdate()
{
float deltaTime = Time.deltaTime;
if (this.m_character)
{
this.m_character.IsSwiming();
}
for (int i = 0; i < this.m_positions.Count; i++)
{
Tail.TailSegment tailSegment = this.m_positions[i];
if (this.m_waterSurfaceCheck)
{
float waterLevel = WaterVolume.GetWaterLevel(tailSegment.pos, 1f);
if (tailSegment.pos.y + this.m_tailRadius > waterLevel)
{
Tail.TailSegment tailSegment2 = tailSegment;
tailSegment2.pos.y = tailSegment2.pos.y - this.m_gravity * deltaTime;
}
else
{
Tail.TailSegment tailSegment3 = tailSegment;
tailSegment3.pos.y = tailSegment3.pos.y - this.m_gravityInWater * deltaTime;
}
}
else
{
Tail.TailSegment tailSegment4 = tailSegment;
tailSegment4.pos.y = tailSegment4.pos.y - this.m_gravity * deltaTime;
}
Vector3 a = tailSegment.transform.parent.position + tailSegment.transform.parent.up * tailSegment.distance * 0.5f;
Vector3 vector = Vector3.Normalize(a - tailSegment.pos);
vector = Vector3.RotateTowards(-tailSegment.transform.parent.up, vector, 0.017453292f * this.m_maxAngle, 1f);
Vector3 vector2 = a - vector * tailSegment.distance * 0.5f;
if (this.m_groundCheck)
{
float groundHeight = ZoneSystem.instance.GetGroundHeight(vector2);
if (vector2.y - this.m_tailRadius < groundHeight)
{
vector2.y = groundHeight + this.m_tailRadius;
}
}
vector2 = Vector3.Lerp(tailSegment.pos, vector2, this.m_smoothness);
Vector3 normalized = (a - vector2).normalized;
Vector3 rhs = Vector3.Cross(Vector3.up, -normalized);
Quaternion quaternion = Quaternion.LookRotation(Vector3.Cross(-normalized, rhs), -normalized);
quaternion = Quaternion.Slerp(tailSegment.rot, quaternion, this.m_smoothness);
tailSegment.transform.position = vector2;
tailSegment.transform.rotation = quaternion;
tailSegment.pos = vector2;
tailSegment.rot = quaternion;
}
if (this.m_tailBody)
{
this.m_tailBody.velocity = Vector3.zero;
this.m_tailBody.angularVelocity = Vector3.zero;
}
}
// Token: 0x06000D2B RID: 3371 RVA: 0x0005E128 File Offset: 0x0005C328
public bool IsBurning()
{
if (this.m_blocked)
{
return(false);
}
float waterLevel = WaterVolume.GetWaterLevel(this.m_enabledObject.transform.position, 1f);
return(this.m_enabledObject.transform.position.y >= waterLevel && this.m_nview.GetZDO().GetFloat("fuel", 0f) > 0f);
}
// Token: 0x06000FF7 RID: 4087 RVA: 0x00070654 File Offset: 0x0006E854
private void Update()
{
this.m_cooldownTimer += Time.deltaTime;
if (this.m_cooldownTimer > this.m_cooldownDelay)
{
float waterLevel = WaterVolume.GetWaterLevel(base.transform.position, 1f);
if (base.transform.position.y < waterLevel)
{
this.m_effects.Create(base.transform.position, base.transform.rotation, base.transform, 1f);
this.m_cooldownTimer = 0f;
}
}
}
// Token: 0x06000302 RID: 770 RVA: 0x00019928 File Offset: 0x00017B28
private void FixedUpdate()
{
if (!this.m_nview.IsValid())
{
return;
}
this.UpdateRotation(Time.fixedDeltaTime);
if (!this.m_nview.IsOwner())
{
return;
}
if (!this.m_didHit)
{
Vector3 position = base.transform.position;
this.m_vel += Vector3.down * this.m_gravity * Time.fixedDeltaTime;
base.transform.position += this.m_vel * Time.fixedDeltaTime;
if (this.m_rotateVisual == 0f)
{
base.transform.rotation = Quaternion.LookRotation(this.m_vel);
}
if (this.m_canHitWater)
{
float waterLevel = WaterVolume.GetWaterLevel(base.transform.position, 1f);
if (base.transform.position.y < waterLevel)
{
this.OnHit(null, base.transform.position, true);
}
}
if (!this.m_didHit)
{
Vector3 b = base.transform.position - position;
foreach (RaycastHit raycastHit in Physics.SphereCastAll(position - b, this.m_rayRadius, b.normalized, b.magnitude * 2f, Projectile.m_rayMaskSolids))
{
this.OnHit(raycastHit.collider, raycastHit.point, false);
if (this.m_didHit)
{
break;
}
}
}
}
if (this.m_ttl > 0f)
{
this.m_ttl -= Time.fixedDeltaTime;
if (this.m_ttl <= 0f)
{
ZNetScene.instance.Destroy(base.gameObject);
}
}
}
// Token: 0x06000262 RID: 610 RVA: 0x000135F0 File Offset: 0x000117F0
private void UpdateFloating(float dt)
{
foreach (Rigidbody rigidbody in this.m_bodies)
{
Vector3 worldCenterOfMass = rigidbody.worldCenterOfMass;
worldCenterOfMass.y += this.m_floatOffset;
float waterLevel = WaterVolume.GetWaterLevel(worldCenterOfMass, 1f);
if (worldCenterOfMass.y < waterLevel)
{
float d = (waterLevel - worldCenterOfMass.y) / 0.5f;
Vector3 a = Vector3.up * 20f * d;
rigidbody.AddForce(a * dt, ForceMode.VelocityChange);
rigidbody.velocity -= rigidbody.velocity * 0.05f * d;
}
}
}
// Token: 0x06000AE3 RID: 2787 RVA: 0x0004E2F0 File Offset: 0x0004C4F0
private void GetCameraPosition(float dt, out Vector3 pos, out Quaternion rot)
{
Player localPlayer = Player.m_localPlayer;
if (localPlayer == null)
{
pos = base.transform.position;
rot = base.transform.rotation;
return;
}
Vector3 vector = this.GetOffsetedEyePos();
float num = this.m_distance;
if (localPlayer.InIntro())
{
vector = localPlayer.transform.position;
num = this.m_flyingDistance;
}
Vector3 vector2 = -localPlayer.m_eye.transform.forward;
if (this.m_smoothYTilt && !localPlayer.InIntro())
{
num = Mathf.Lerp(num, 1.5f, Utils.SmoothStep(0f, -0.5f, vector2.y));
}
Vector3 vector3 = vector + vector2 * num;
this.CollideRay2(localPlayer.m_eye.position, vector, ref vector3);
this.UpdateNearClipping(vector, vector3, dt);
float waterLevel = WaterVolume.GetWaterLevel(vector3, 1f);
if (vector3.y < waterLevel + this.m_minWaterDistance)
{
vector3.y = waterLevel + this.m_minWaterDistance;
this.m_waterClipping = true;
}
else
{
this.m_waterClipping = false;
}
pos = vector3;
rot = localPlayer.m_eye.transform.rotation;
if (this.m_shipCameraTilt)
{
this.ApplyCameraTilt(localPlayer, dt, ref rot);
}
}
// Token: 0x06000EDA RID: 3802 RVA: 0x00069EA4 File Offset: 0x000680A4
private void FixedUpdate()
{
bool flag = this.HaveControllingPlayer();
this.UpdateControlls(Time.fixedDeltaTime);
this.UpdateSail(Time.fixedDeltaTime);
this.UpdateRudder(Time.fixedDeltaTime, flag);
if (this.m_nview && !this.m_nview.IsOwner())
{
return;
}
this.UpdateUpsideDmg(Time.fixedDeltaTime);
if (this.m_players.Count == 0)
{
this.m_speed = Ship.Speed.Stop;
this.m_rudderValue = 0f;
}
if (!flag && (this.m_speed == Ship.Speed.Slow || this.m_speed == Ship.Speed.Back))
{
this.m_speed = Ship.Speed.Stop;
}
float waveFactor = 1f;
Vector3 worldCenterOfMass = this.m_body.worldCenterOfMass;
Vector3 vector = this.m_floatCollider.transform.position + this.m_floatCollider.transform.forward * this.m_floatCollider.size.z / 2f;
Vector3 vector2 = this.m_floatCollider.transform.position - this.m_floatCollider.transform.forward * this.m_floatCollider.size.z / 2f;
Vector3 vector3 = this.m_floatCollider.transform.position - this.m_floatCollider.transform.right * this.m_floatCollider.size.x / 2f;
Vector3 vector4 = this.m_floatCollider.transform.position + this.m_floatCollider.transform.right * this.m_floatCollider.size.x / 2f;
float waterLevel = WaterVolume.GetWaterLevel(worldCenterOfMass, waveFactor);
float waterLevel2 = WaterVolume.GetWaterLevel(vector3, waveFactor);
float waterLevel3 = WaterVolume.GetWaterLevel(vector4, waveFactor);
float waterLevel4 = WaterVolume.GetWaterLevel(vector, waveFactor);
float waterLevel5 = WaterVolume.GetWaterLevel(vector2, waveFactor);
float num = (waterLevel + waterLevel2 + waterLevel3 + waterLevel4 + waterLevel5) / 5f;
float num2 = worldCenterOfMass.y - num - this.m_waterLevelOffset;
if (num2 > this.m_disableLevel)
{
return;
}
this.m_body.WakeUp();
this.UpdateWaterForce(num2, Time.fixedDeltaTime);
ref Vector3 ptr = new Vector3(vector3.x, waterLevel2, vector3.z);
void Update()
{
waterRenderer.material.SetVector("_Position", transform.position);
foreach (ParticleSystem ripple in ripplesInsideWater)
{
Vector3 nearestSurfacePoint = ripple.transform.position;
nearestSurfacePoint.y = waterVolume.GetWaterLevel(nearestSurfacePoint);
if (ripple.GetComponentInParent <Collider>().bounds.Contains(nearestSurfacePoint))
{
if (!ripple.isPlaying)
{
ripple.Play();
}
}
else
{
if (ripple.isPlaying)
{
ripple.Stop();
}
}
}
}
// Token: 0x06000F0E RID: 3854 RVA: 0x0006BA8C File Offset: 0x00069C8C
private void LateUpdate()
{
float waterLevel = WaterVolume.GetWaterLevel(base.transform.position, 1f);
ref Vector3 position = base.transform.position;
// Token: 0x06001024 RID: 4132 RVA: 0x00071FD4 File Offset: 0x000701D4
private bool IsUnderWater()
{
float waterLevel = WaterVolume.GetWaterLevel(base.transform.position, 1f);
return(base.transform.position.y < waterLevel);
}