using System;
using System.Collections;
using System.Collections.Generic;
using DarkTonic.MasterAudio;
using Pathfinding;
using UnityEngine;

// Token: 0x02000016 RID: 22
public class Boat : MonoBehaviour
{
	// Token: 0x06000217 RID: 535 RVA: 0x0002CB28 File Offset: 0x0002AD28
	private void Awake()
	{
		this.tr = base.transform;
		this.originalScale = this.tr.localScale;
		this.bouyancy = base.gameObject.GetComponent<RamBuoyancy>();
		if (!this.bouyancy)
		{
			this.useBuoyancy = false;
		}
		this.rbody = base.gameObject.GetComponent<Rigidbody>();
		this.rbody.isKinematic = true;
		this.rbody.useGravity = false;
		if (this.useBuoyancy)
		{
			this.bouyancy.enabled = false;
		}
		this.moveFollow = this.tr;
		base.gameObject.layer = 18;
		for (int i = 0; i < this.renderers.Length; i++)
		{
			this.renderers[i].gameObject.layer = 18;
		}
		this.tr.localScale = this.originalScale;
		if (this.animator)
		{
			this.animator.updateMode = AnimatorUpdateMode.Normal;
		}
	}

	// Token: 0x06000218 RID: 536 RVA: 0x0002CC20 File Offset: 0x0002AE20
	private void Start()
	{
		this.settingPosition = false;
		if (this.partyBoat && !this.boatFollow)
		{
			GameObject gameObject = new GameObject("Boat Follow");
			this.boatFollow = gameObject.transform;
			this.boatFollow.SetParent(this.tr, true);
			this.boatFollow.SetParent(null, true);
		}
		if (this.inMenu)
		{
			for (int i = 0; i < this.renderers.Length; i++)
			{
				this.renderers[i].gameObject.layer = 25;
			}
			this.tr.localScale = new Vector3(0.4f, 0.4f, 0.4f);
			if (this.animator)
			{
				this.animator.updateMode = AnimatorUpdateMode.UnscaledTime;
				this.animator.Play(this.animationOpenName, 0, 0.99f);
			}
		}
	}

	// Token: 0x06000219 RID: 537 RVA: 0x0002CD00 File Offset: 0x0002AF00
	private void Update()
	{
		if (this.sailing && !Records.x.typing && Links.x.gaia.sceneLoaded && Links.x.gaia.pathfindingReady && !this.settingPosition)
		{
			if (this.canExit && Input.GetKeyDown(Links.x.keyControl.GetHotkey("Interact")))
			{
				this.GetOffBoat();
			}
			if (Time.timeSinceLevelLoad > this.updateTime + 1f)
			{
				this.CheckInTile();
				this.updateTime = Time.timeSinceLevelLoad;
				this.updateTimeCount++;
				if (this.updateTimeCount > 100)
				{
					this.updateTimeCount = 0;
					this.ResetNode();
				}
			}
			if (!this.leavingBoat)
			{
				float magnitude = this.rbody.linearVelocity.magnitude;
				float magnitude2 = this.rbody.angularVelocity.magnitude;
				for (int i = 0; i < this.sailors.Count; i++)
				{
					Character character = this.sailors[i];
					if (character && !character.jumping)
					{
						character.SetPosition(this.standingSpots[i].position, null);
						if (!character.isBoro && !character.stats.animal)
						{
							float num = 6f;
							bool flag = false;
							if (magnitude2 > 1f)
							{
								bool flag2 = this.IsSailorLeft(character);
								if (!this.turningLeft && !flag2)
								{
									flag = true;
								}
								if (this.turningLeft && flag2)
								{
									flag = true;
								}
							}
							float num2;
							if (character.animator.GetBool("Combat"))
							{
								num2 = character.animator.GetFloat("Combat Variation");
							}
							else
							{
								num2 = character.animator.GetFloat("Idle Variation");
							}
							if ((magnitude > 1f || magnitude2 > 1f) && !flag && (this.physicsMove || this.movePoint != Vector3.zero || this.turning))
							{
								if (num2 < 0.99f)
								{
									character.animator.SetFloat("Idle Variation", Mathf.Lerp(num2, 1f, Time.deltaTime * num));
									character.animator.SetFloat("Combat Variation", Mathf.Lerp(num2, 1f, Time.deltaTime * num));
								}
								else
								{
									character.animator.SetFloat("Idle Variation", 1f);
									character.animator.SetFloat("Combat Variation", 1f);
								}
								if (!character.oar)
								{
									character.NeedToUpdateSailingAnimator(false);
								}
							}
							else if (num2 > 0.01f)
							{
								character.animator.SetFloat("Idle Variation", Mathf.Lerp(num2, 0f, Time.deltaTime * num));
								character.animator.SetFloat("Combat Variation", Mathf.Lerp(num2, 0f, Time.deltaTime * num));
							}
							else
							{
								character.animator.SetFloat("Idle Variation", 0f);
								character.animator.SetFloat("Combat Variation", 0f);
							}
						}
						bool flag3 = true;
						if (character.hasActions)
						{
							flag3 = character.oar;
						}
						if (flag3)
						{
							character.SetRotation(Quaternion.Slerp(character.tr.rotation, this.standingSpots[i].rotation, Time.deltaTime * 40f), false, true);
						}
					}
				}
				if (this.splashFront)
				{
					float num3 = this.tr.position.y + 1f;
					num3 = Links.x.diorama.waterY + 0.1f;
					Vector3 eulerAngles = this.tr.rotation.eulerAngles;
					eulerAngles.x = 0f;
					eulerAngles.z = 0f;
					Quaternion quaternion = Quaternion.Euler(eulerAngles);
					if (!this.splashFront.activeSelf)
					{
						this.splashFront.SetActive(true);
					}
					this.splashFront.transform.position = new Vector3(this.tr.position.x, num3, this.tr.position.z);
					this.splashFront.transform.rotation = quaternion;
					if (!this.splashBack.activeSelf)
					{
						this.splashBack.SetActive(true);
					}
					this.splashBack.transform.position = new Vector3(this.tr.position.x, num3, this.tr.position.z);
					this.splashBack.transform.rotation = quaternion;
					int num4 = Mathf.RoundToInt(magnitude * 4f);
					int num5 = Mathf.RoundToInt(magnitude * 1.5f);
					for (int j = 0; j < this.splashParticles.Count; j++)
					{
						ParticleSystem.MainModule main = this.splashParticles[j].main;
						if (this.splashParticles[j].gameObject.name.Contains("Splash"))
						{
							main.maxParticles = num5;
						}
						else
						{
							main.maxParticles = num4;
						}
					}
				}
				if (this.partyBoat)
				{
					Links.x.gaia.boro.SetPosition(this.standingSpots[4].position, null);
					Links.x.gaia.boro.SetRotation(this.standingSpots[4].rotation, false, true);
				}
			}
			float x = this.tr.rotation.eulerAngles.x;
			float z = this.tr.rotation.eulerAngles.z;
			if (this.navigator && this.startSailCoroutine == null)
			{
				if ((x > 30f && x < 330f) || (z > 30f && z < 330f) || this.tr.position.y < Links.x.diorama.boatColliderY)
				{
					if (!this.isCapsized)
					{
						this.startCapsizedRot = this.tr.rotation;
					}
					this.isCapsized = true;
					float num6 = this.tr.rotation.eulerAngles.x;
					float num7 = this.tr.rotation.eulerAngles.z;
					float num8 = 900f * Time.deltaTime;
					if (x > 30f && x < 330f)
					{
						if (x < 180f)
						{
							num6 -= num8;
						}
						if (x >= 180f)
						{
							num6 += num8;
						}
					}
					else if (z > 30f && z < 330f)
					{
						if (z < 180f)
						{
							num7 -= num8;
						}
						if (z >= 180f)
						{
							num7 += num8;
						}
					}
					this.rbody.rotation = Quaternion.Euler(new Vector3(num6, this.tr.rotation.eulerAngles.y, num7));
					if (this.navigator)
					{
						this.rbody.isKinematic = true;
					}
					if (this.tr.position.y < Links.x.diorama.boatColliderY)
					{
						this.tr.position += Vector3.up * Time.deltaTime * 50f;
					}
				}
				else
				{
					this.isCapsized = false;
					if (this.navigator)
					{
						this.rbody.isKinematic = false;
					}
				}
			}
			else
			{
				this.isCapsized = false;
			}
		}
		if (this.sailing)
		{
			if (Records.x.pocketPause && !this.pocket)
			{
				this.pocket = true;
				this.savedVelocity = this.rbody.linearVelocity;
				this.savedAngularVelocity = this.rbody.angularVelocity;
				this.rbody.isKinematic = true;
				return;
			}
			if (!Records.x.pocketPause && this.pocket)
			{
				this.pocket = false;
				this.rbody.isKinematic = false;
				this.rbody.AddForce(this.savedVelocity, ForceMode.VelocityChange);
				this.rbody.AddTorque(this.savedAngularVelocity, ForceMode.VelocityChange);
			}
		}
	}

	// Token: 0x0600021A RID: 538 RVA: 0x0002D570 File Offset: 0x0002B770
	private void LateUpdate()
	{
		if (this.sailing && this.partyBoat)
		{
			this.BoatFollow();
		}
	}

	// Token: 0x0600021B RID: 539 RVA: 0x0002D588 File Offset: 0x0002B788
	public void NewPoint(Vector3 pt, GraphNode targetNode)
	{
		this.movePoint = pt;
		Vector3 vector = this.movePoint;
		vector.y = this.tr.position.y;
		this.look = Quaternion.LookRotation(vector - this.tr.position);
		this.rot = this.look;
		this.moveDistance = (vector - this.tr.position).sqrMagnitude;
		this.closeToPoint = false;
		this.savedTargetNode = targetNode;
		this.prevDist = 1000000f;
		this.turning = false;
		if ((Links.x.rtsCamera.cameraTargetTr.position - this.tr.position).sqrMagnitude < 625f)
		{
			MasterAudio.PlaySound3DAtVector3AndForget("Splash", this.tr.position, Random.Range(0.8f, 1f), new float?(Random.Range(0.95f, 1f)), 0f, "", null);
		}
	}

	// Token: 0x0600021C RID: 540 RVA: 0x0002D6A0 File Offset: 0x0002B8A0
	private void BoatFollow()
	{
		if (Records.x.pocketPause)
		{
			return;
		}
		Vector3 vector = Vector3.Lerp(this.boatFollow.position, this.tr.position, Time.unscaledDeltaTime * 2f);
		if (this.node != null)
		{
			Vector3 vector2 = (Vector3)this.node.position;
			vector.y = vector2.y;
		}
		this.boatFollow.position = vector;
		if (this.noiseUpdateTime > Time.timeSinceLevelLoad + 2f)
		{
			this.noiseUpdateTime = Time.timeSinceLevelLoad;
			for (int i = 0; i < this.sailors.Count; i++)
			{
				Links.x.sensory.AddFootstep(this.sailors[i]);
			}
		}
	}

	// Token: 0x0600021D RID: 541 RVA: 0x0002D764 File Offset: 0x0002B964
	private void StopMove()
	{
		if (!this.mainTurning)
		{
			this.moving = false;
		}
		if (this.rbody.linearVelocity.magnitude < 0.01f && !this.mainTurning)
		{
			this.physicsMove = false;
		}
	}

	// Token: 0x0600021E RID: 542 RVA: 0x0002D7AC File Offset: 0x0002B9AC
	private void FixedUpdate()
	{
		if (this.sailing)
		{
			if (Records.x.pocketPause)
			{
				return;
			}
			bool flag = true;
			if (this.partyBoat && Links.x.joy)
			{
				flag = false;
			}
			this.t1 += Time.deltaTime * 5f;
			this.waveValue = Mathf.Lerp(this.startValue1, this.targetValue1, this.t1);
			if (this.waveValue >= this.targetValue1 && this.targetValue1 > 50f)
			{
				this.targetValue1 = Random.Range(0f, 10f);
				this.startValue1 = this.waveValue;
				this.t1 = 0f;
			}
			if (this.waveValue <= this.targetValue1 && this.targetValue1 < 50f)
			{
				this.startValue1 = this.waveValue;
				this.targetValue1 = Random.Range(90f, 100f);
				this.t1 = 0f;
			}
			this.rbody.AddForce(Vector3.up * (-1f * this.waveValue * this.waveMultiplier) * Time.fixedDeltaTime, ForceMode.Force);
			if (!this.isCapsized)
			{
				if (this.partyBoat)
				{
					bool flag2 = false;
					if (Input.GetKey(Links.x.gameplay.keyControl.GetHotkey("Left")) || Input.GetKey(Links.x.gameplay.keyControl.GetHotkey("Right")) || Input.GetKey(Links.x.gameplay.keyControl.GetHotkey("Up")) || Input.GetKey(Links.x.gameplay.keyControl.GetHotkey("Down")))
					{
						flag2 = true;
					}
					bool flag3 = this.physicsMove;
					Vector3 one = Vector3.one;
					Quaternion quaternion = this.rot;
					this.physicsMove = Links.x.fellowship.GetDirection(Links.x.main, out quaternion, out one);
					if (this.physicsMove && !Links.x.main.CanPhysicsMove(flag2))
					{
						this.physicsMove = false;
					}
					if (this.physicsMove)
					{
						this.rot = this.tr.rotation;
						if (this.previouslyMovingStartTime == 0f && !flag3)
						{
							this.previouslyMovingStartTime = Time.timeSinceLevelLoad;
						}
						if (this.previouslyMovingStartTime > 0f && Time.timeSinceLevelLoad > this.previouslyMovingStartTime + 0.05f)
						{
							this.previouslyMovingStartTime = 0f;
						}
						if (this.navigator && this.navigator.waypoint && this.navigator.waypoint.transform.position.x != Links.x.gameplay.farPosition.x)
						{
							this.navigator.waypoint.transform.position = Links.x.gameplay.farPosition;
						}
						if (!flag3 && (Links.x.gameplay.holdingMouseButton || flag2))
						{
							this.navigator.ClearMoveTargets();
						}
						if ((Links.x.gameplay.holdingMouseButton || (flag2 && !flag3)) && this.navigator)
						{
							this.navigator.ClearNodePath();
							this.movePoint = Vector3.zero;
						}
						if (!Records.x.pocketPause && Records.x.InCombat(false) && Links.x.combat.GetNPCCountHostile() == 0 && Links.x.main.attackTime >= 1f)
						{
							Links.x.combat.EndCombat(false);
						}
						bool flag4 = true;
						this.rot = Quaternion.Slerp(this.tr.rotation, quaternion, Time.fixedDeltaTime * 30f);
						Vector3 vector = this.tr.position + this.rot * Vector3.forward * 2f;
						GraphNode graphNode = this.NearNode(vector, false, 0, -1);
						if (graphNode != null)
						{
							Vector3 vector2 = (Vector3)graphNode.position;
							if ((new Vector3(vector2.x, vector.y, vector2.z) - vector).sqrMagnitude > 30.25f)
							{
								flag4 = false;
							}
						}
						else
						{
							flag4 = false;
							this.rbody.linearVelocity *= 0.5f;
						}
						this.smoothRot = this.tr.rotation;
						Vector3 vector3 = Quaternion.Euler(0f, this.tr.rotation.eulerAngles.y, 0f) * Vector3.forward;
						this.targetRotation = Quaternion.Euler(0f, quaternion.eulerAngles.y, 0f);
						Vector3 vector4 = this.targetRotation * Vector3.forward;
						float num = Vector3.Dot(vector3, vector4);
						bool flag5 = this.moving;
						bool flag6 = true;
						float num2 = Quaternion.Angle(this.targetRotation, this.tr.rotation);
						if (Mathf.Abs(num2) > 8f && this.navigator.NodesCount() == 0)
						{
							float num3 = this.rbody.linearVelocity.sqrMagnitude / 100f;
							bool flag7 = false;
							if (this.AngleDir(this.tr.forward, this.targetRotation * Vector3.forward, this.tr.up) < 0f)
							{
								flag7 = true;
								this.turningLeft = true;
							}
							else
							{
								this.turningLeft = false;
							}
							float num4 = 30f * (Mathf.Abs(num2) / 200f) + num3;
							if (flag7)
							{
								num4 *= -1f;
							}
							this.rbody.AddTorque(new Vector3(0f, num4, 0f) * this.turnSpeed * 50f * Time.fixedDeltaTime);
						}
						if (((flag5 && num < -0.2f) || (!flag5 && num < 0.6f)) && flag6 && !Records.x.pocketPause)
						{
							this.mainTurning = true;
						}
						else
						{
							this.mainTurning = false;
						}
						if (flag4 && !this.mainTurning)
						{
							this.moving = true;
							if (graphNode != this.node)
							{
								this.ClaimNode(graphNode, (Vector3)graphNode.position, false);
							}
							float num5 = Mathf.Clamp((180f - Mathf.Abs(num2)) / 180f, 0.5f, 1f);
							this.rbody.AddForce(this.tr.rotation * Vector3.forward * this.GetSpeed() * num5 * Time.fixedDeltaTime, ForceMode.Acceleration);
						}
						this.turning = false;
						this.rotating = false;
					}
					else if (this.navigator && !this.navigator.moving)
					{
						this.StopMove();
					}
				}
				if (this.navigator && flag)
				{
					if (this.navigator.moving && this.navigator.blockedTime == 0f && !this.navigator.waitingForNewPath && this.navigator.NodesCount() > 0 && this.movePoint != Vector3.zero)
					{
						Vector3 vector5 = this.movePoint;
						vector5.y = this.tr.position.y;
						Vector3 vector6 = vector5 - this.tr.position;
						float sqrMagnitude = vector6.sqrMagnitude;
						Vector3 vector7 = this.tr.TransformDirection(Vector3.forward);
						Vector3 vector8 = Vector3.Normalize(vector6);
						float num6 = Vector3.Dot(vector7, vector8);
						float num7 = Quaternion.Angle(this.rot, this.savedRot);
						this.smoothRot = this.tr.rotation;
						if (this.turning || (sqrMagnitude > 9f && num6 < 0.65f))
						{
							this.angleRemaining = Quaternion.Angle(this.rot, this.smoothRot);
							this.intervalAngleRemaining = Quaternion.Angle(this.intervalRot, this.smoothRot);
							float num8 = Quaternion.Angle(this.tr.rotation, this.smoothRot);
							if (this.turning && (this.rot == this.smoothRot || this.angleRemaining < 15f) && num7 < 15f)
							{
								this.EndTurning();
							}
							else if (num7 >= 15f || this.intervalAngleRemaining < 15f || !this.turning || num8 < 5f)
							{
								this.rotationTime = 0f;
								this.startRot = this.smoothRot;
								this.startRotY = this.startRot.eulerAngles.y;
								this.turning = true;
								this.savedRot = this.rot;
								float num9 = this.AngleDir(this.tr.forward, this.rot * Vector3.forward, Vector3.up);
								float num10 = this.angleRemaining;
								if (num10 <= 45f)
								{
									Vector3 eulerAngles = this.smoothRot.eulerAngles;
									this.intervalY = eulerAngles.y + num10 * num9;
									this.intervalRot = this.rot;
								}
								else
								{
									Vector3 eulerAngles2 = this.smoothRot.eulerAngles;
									this.intervalY = eulerAngles2.y + 45f * num9;
									this.intervalRot = Quaternion.Euler(new Vector3(eulerAngles2.x, this.intervalY, eulerAngles2.z));
								}
							}
							if (this.turning)
							{
								this.rotating = false;
								Vector3 vector9 = this.tr.position + this.tr.forward * 1f;
								bool flag8;
								if ((vector9 - (Vector3)this.node.position).sqrMagnitude > 1f)
								{
									GraphNode graphNode2 = this.NearNode(vector9, true, 0, -1);
									if (graphNode2 != null)
									{
										if (((Vector3)graphNode2.position - vector9).sqrMagnitude < 1f)
										{
											flag8 = true;
											this.ClaimNode(graphNode2, (Vector3)graphNode2.position, false);
											MasterAudio.PlaySound3DAtVector3AndForget("Splash", this.tr.position, Random.Range(0.8f, 1f), new float?(Random.Range(0.95f, 1f)), 0f, "", null);
										}
										else
										{
											flag8 = false;
										}
									}
									else
									{
										flag8 = false;
									}
								}
								else
								{
									flag8 = true;
								}
								if (flag8)
								{
									if (this.navigator.npc)
									{
										this.rbody.AddForce(this.tr.forward * this.GetSpeed() * 0.5f * Time.fixedDeltaTime, ForceMode.Force);
									}
									else
									{
										this.rbody.AddForce(this.tr.forward * this.GetSpeed() * 8f * Time.fixedDeltaTime, ForceMode.Force);
									}
								}
								else
								{
									this.rbody.linearVelocity *= 0.8f;
								}
							}
						}
						if (!this.closeToPoint && !this.turning)
						{
							if (sqrMagnitude > 1f && !this.closeToPoint && sqrMagnitude < this.prevDist)
							{
								this.rotating = true;
								this.rbody.AddForce(this.look * Vector3.forward * this.GetSpeed() * Time.fixedDeltaTime, ForceMode.Acceleration);
								this.prevDist = sqrMagnitude;
							}
							else
							{
								this.rotating = false;
								this.closeToPoint = true;
							}
						}
						if (!Records.x.pocketPause)
						{
							if (this.turning)
							{
								this.rbody.useGravity = true;
								float num11 = 2f;
								this.rotationTime += Time.deltaTime * num11;
								float num12 = Mathf.Lerp(this.startRotY, this.intervalY, this.rotationTime);
								this.smoothRot = Quaternion.Euler(new Vector3(0f, num12, 0f));
							}
							else if (this.rotating && !this.turning)
							{
								this.rbody.useGravity = true;
								this.smoothRot = Quaternion.Slerp(this.smoothRot, this.rot, Time.deltaTime * this.turnSpeed);
							}
							Vector3 eulerAngles3 = this.tr.rotation.eulerAngles;
							if (this.turning || this.rotating)
							{
								float num13 = Quaternion.Angle(this.rot, this.tr.rotation);
								if (num13 > 7f || this.turning)
								{
									bool flag9 = false;
									Vector3 vector10 = this.movePoint - this.tr.position;
									if (this.AngleDir(this.tr.forward, Vector3.Normalize(vector10), this.tr.up) < 0f)
									{
										flag9 = true;
										this.turningLeft = true;
									}
									else
									{
										this.turningLeft = false;
									}
									float num14 = 0.5f;
									if (this.navigator.npc)
									{
										num14 = 0.3f;
									}
									float num15 = Mathf.Clamp(Mathf.Abs(num13) / 180f, num14, 1f);
									float num16 = 90f * num15;
									if (flag9)
									{
										num16 *= -1f;
									}
									this.rbody.AddTorque(new Vector3(0f, num16, 0f) * this.turnSpeed * 10f * Time.fixedDeltaTime);
									return;
								}
								this.rotating = false;
								return;
							}
						}
					}
					else if (this.movePoint == Vector3.zero && (!this.partyBoat || (this.partyBoat && !this.physicsMove)))
					{
						this.turning = false;
						this.movePoint = Vector3.zero;
					}
				}
			}
		}
	}

	// Token: 0x0600021F RID: 543 RVA: 0x0002E5B0 File Offset: 0x0002C7B0
	public void StopBoat()
	{
		this.movePoint = Vector3.zero;
		if (this.navigator)
		{
			this.navigator.sphere.transform.position = this.tr.position;
			this.navigator.TargetReached();
		}
	}

	// Token: 0x06000220 RID: 544 RVA: 0x0002E600 File Offset: 0x0002C800
	private float GetSpeed()
	{
		if (this.partyBoat)
		{
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			return (this.speed + Links.x.fellowship.GetSailingSpeed(out num, out num2, out num3, out num4)) * 100f;
		}
		return this.speed;
	}

	// Token: 0x06000221 RID: 545 RVA: 0x0002E658 File Offset: 0x0002C858
	private void EndTurning()
	{
		if (this.turning)
		{
			this.turning = false;
			Vector3 vector = this.movePoint;
			vector.y = this.tr.position.y;
			Vector3 vector2 = vector - this.tr.position;
			Vector3 vector3 = this.tr.TransformDirection(Vector3.forward);
			Vector3 vector4 = Vector3.Normalize(vector2);
			if (Vector3.Dot(vector3, vector4) < 0.5f)
			{
				this.navigator.EarlyFinish(false);
				if (!this.navigator.npc)
				{
					this.navigator.showWaypoint = true;
				}
				if (Time.timeSinceLevelLoad > this.timeSincePath + 0.25f || this.timeSincePath == 0f)
				{
					this.navigator.MakePath(this.savedTargetNode, 500, false, false, true);
					this.timeSincePath = Time.timeSinceLevelLoad;
					return;
				}
			}
			else
			{
				this.prevDist = vector2.sqrMagnitude + 0.2f;
			}
		}
	}

	// Token: 0x06000222 RID: 546 RVA: 0x0002E748 File Offset: 0x0002C948
	public void TargetReached()
	{
		this.movePoint = Vector3.zero;
	}

	// Token: 0x06000223 RID: 547 RVA: 0x0002E758 File Offset: 0x0002C958
	public void HoverIn()
	{
		for (int i = 0; i < this.renderers.Length; i++)
		{
			if (this.renderers[i] && this.renderers[i].gameObject.layer != 29)
			{
				this.mats = this.renderers[i].materials;
				Material[] array = this.mats;
				for (int j = 0; j < array.Length; j++)
				{
					array[j].SetFloat("_Hover", 1f);
				}
			}
		}
	}

	// Token: 0x06000224 RID: 548 RVA: 0x0002E7D8 File Offset: 0x0002C9D8
	public void HoverOut()
	{
		for (int i = 0; i < this.renderers.Length; i++)
		{
			if (this.renderers[i] && this.renderers[i].gameObject.layer != 29)
			{
				this.mats = this.renderers[i].materials;
				Material[] array = this.mats;
				for (int j = 0; j < array.Length; j++)
				{
					array[j].SetFloat("_Hover", 0f);
				}
			}
		}
	}

	// Token: 0x06000225 RID: 549 RVA: 0x0002E858 File Offset: 0x0002CA58
	public bool CanEnterLeaveBoat()
	{
		bool flag = true;
		this.party = Links.x.portraitOrder;
		for (int i = 0; i < this.party.Count; i++)
		{
			if (this.party[i] && !this.party[i].summoned && !this.party[i].isBoro && (!this.party[i].IsSentient() || this.party[i].isHit || this.party[i].stats.pinned || this.party[i].stats.pinning || this.party[i].stats.Stuck() != 0 || this.party[i].stats.Confuse() != 0))
			{
				flag = false;
				break;
			}
		}
		return flag;
	}

	// Token: 0x06000226 RID: 550 RVA: 0x0002E960 File Offset: 0x0002CB60
	public bool CanSail(out bool onBeach)
	{
		bool flag = true;
		onBeach = false;
		this.party = Links.x.portraitOrder;
		for (int i = 0; i < this.party.Count; i++)
		{
			if (this.party[i] && flag && !this.party[i].summoned && !this.party[i].isBoro && this.party[i].IsSentient() && !this.party[i].mainSelected && (this.party[i].tr.position - Links.x.main.tr.position).sqrMagnitude > 400f)
			{
				flag = false;
			}
		}
		if (this.party.Count == 0)
		{
			return false;
		}
		if (Records.x.InCombat(false))
		{
			flag = false;
		}
		return flag;
	}

	// Token: 0x06000227 RID: 551 RVA: 0x0002EA64 File Offset: 0x0002CC64
	public void GetOnWater()
	{
		bool flag = false;
		if (!this.CanSail(out flag))
		{
			Links.x.gameFeed.AddFeed("Cannot sail right now, party is busy");
			return;
		}
		if (Links.x.gaia.pathfindingReady && this.startSailCoroutine == null)
		{
			base.enabled = true;
			base.gameObject.SetActive(true);
			this.boat.SetActive(false);
			this.startSailCoroutine = this.BoatToWater();
			base.StartCoroutine(this.startSailCoroutine);
		}
	}

	// Token: 0x06000228 RID: 552 RVA: 0x0002EAE3 File Offset: 0x0002CCE3
	private IEnumerator BoatToWater()
	{
		this.settingPosition = false;
		if (Records.x.circle)
		{
			Links.x.fellowship.BreakCircle(false);
		}
		Records.x.RemoveControls(true);
		Records.x.holdCombat = true;
		if (Records.x.paused)
		{
			Links.x.gameplay.TogglePause(false);
		}
		if (!this.tr)
		{
			this.tr = base.transform;
		}
		this.rbody.isKinematic = true;
		if (this.useBuoyancy)
		{
			this.bouyancy.enabled = false;
		}
		for (int l = 0; l < this.states.Length; l++)
		{
			this.states[l] = "";
		}
		Character boro = Links.x.gaia.boro;
		bool boroMovesToWater = false;
		float radius = 20f;
		GraphNode centerNode = Links.x.main.node;
		this.SetNodeConstraint(null, false);
		this.SetNodeConstraint(null, false);
		this.nodeConstraint.checkConnections = 0;
		this.nodeConstraint.constrainWalkability = false;
		centerNode = Links.x.gaia.exteriorGraph.GetNearestForce(Links.x.main.tr.position, this.nodeConstraint).node;
		this.nodeConstraint.constrainToEnvironment = -1;
		this.nodeConstraint.constrainWalkability = false;
		ConstantPath constPath = ConstantPath.ConstructFast(centerNode, Records.x.GetConstantPathRadius((int)radius), null);
		constPath.nnConstraint = this.nodeConstraint;
		AstarPath.StartPath(constPath, false);
		yield return base.StartCoroutine(constPath.WaitForPath());
		constPath.Claim(this);
		this.allNodes = constPath.allNodes;
		int num = this.allNodes.Count;
		Vector3 zero = Vector3.zero;
		Vector3 zero2 = Vector3.zero;
		Vector3 zero3 = Vector3.zero;
		Vector3 zero4 = Vector3.zero;
		Vector3 forward = Vector3.forward;
		Vector3 zero5 = Vector3.zero;
		Vector3 zero6 = Vector3.zero;
		this.SetNodeConstraint(boro, true);
		this.nodeConstraint.uniqueID = 0;
		int count = 0;
		this.suitableNodes.Clear();
		this.moveNodes.Clear();
		this.nodeConstraint.constrainToEnvironment = 2;
		this.nodeConstraint.checkConnections = this.connections;
		this.nodeConstraint.constrainWalkability = true;
		this.nodeConstraint.walkable = true;
		this.nodeConstraint.constrainTags = true;
		this.nodeConstraint.checkCircleID = 0;
		this.nodeConstraint.passID = boro.nodeStationaryID;
		this.nodeConstraint.passID2 = boro.nodeMovingID;
		this.nodeConstraint.constrainPenalty = 0;
		this.nodeConstraint.constrainToArea = -1;
		for (int m = 0; m < num; m++)
		{
			GraphNode graphNode = this.allNodes[m];
			if (((Vector3)graphNode.position - (Vector3)centerNode.position).sqrMagnitude < radius * radius && this.nodeConstraint.Suitable(graphNode))
			{
				this.suitableNodes.Add(graphNode);
			}
		}
		Vector3 position = boro.tr.position;
		Quaternion rot = Links.x.gaia.boro.tr.rotation;
		Vector3 vector = rot.eulerAngles;
		vector.y += 87f;
		rot = Quaternion.Euler(vector);
		this.tr.rotation = rot;
		GraphNode graphNode2 = null;
		GraphNode boatTargetNode = null;
		new Vector3(0f, this.boatOpenJumpPosition.y, 0f);
		Links.x.rtsCamera.ignoreRemoveControls = true;
		Links.x.rtsCamera.EndFollow();
		num = this.suitableNodes.Count;
		float num2 = float.PositiveInfinity;
		Vector3 currentPosition = Links.x.main.currentPosition;
		for (int n = 0; n < num; n++)
		{
			GraphNode graphNode = this.suitableNodes[n];
			float sqrMagnitude = ((Vector3)graphNode.position - currentPosition).sqrMagnitude;
			if (sqrMagnitude < num2)
			{
				num2 = sqrMagnitude;
				graphNode2 = graphNode;
				boatTargetNode = graphNode;
			}
		}
		bool flag;
		if (graphNode2 == null)
		{
			flag = false;
			Links.x.gameFeed.ShowNotice("No place for boat");
		}
		else
		{
			flag = true;
		}
		if (flag && Links.x.gaia.pathfindingReady)
		{
			Records.x.StartUIFade(true, false);
			this.SetSailingState(boro, true);
			Quaternion quaternion = Quaternion.LookRotation((Vector3)boatTargetNode.position - boro.tr.position);
			boro.SetRotation(quaternion, false, false);
			Links.x.gaia.boro.meshAlwaysOff = true;
			Links.x.gaia.boro.SetMeshState(false);
			rot = quaternion;
			vector = rot.eulerAngles;
			vector.y += 87f;
			rot = Quaternion.Euler(vector);
			this.rbody.isKinematic = true;
			if (this.useBuoyancy)
			{
				this.bouyancy.enabled = false;
			}
			this.tr.position = (Vector3)boatTargetNode.position;
			this.tr.rotation = rot;
			this.boatFollow.position = this.tr.position;
			float timeToLerp = 0.25f;
			float percentage = 0f;
			float startTime = Time.time;
			while (percentage < 1f)
			{
				percentage = (Time.time - startTime) / timeToLerp;
				this.tr.position = (Vector3)boatTargetNode.position;
				this.tr.rotation = rot;
				this.boatFollow.position = this.tr.position;
				yield return null;
			}
			this.boat.SetActive(true);
			this.rbody.isKinematic = false;
			this.rbody.useGravity = true;
			timeToLerp = 0.5f;
			percentage = 0f;
			startTime = Time.time;
			while (percentage < 0.25f)
			{
				percentage = (Time.time - startTime) / timeToLerp;
				this.tr.position = (Vector3)boatTargetNode.position;
				this.tr.rotation = rot;
				this.boatFollow.position = this.tr.position;
				yield return null;
			}
			this.ChangeTimeOfDay();
			this.animator.Play(this.animationOpenName, 0, 1f);
			this.node = boatTargetNode;
			this.lastNode = boatTargetNode;
			this.SetNodeID(false, false);
			this.BoatFollow();
			this.rbody.isKinematic = false;
			this.rbody.useGravity = true;
			if (this.useBuoyancy)
			{
				this.bouyancy.enabled = true;
			}
			boro.ignoreRemoveControls = false;
			boro.ignoreNodeIDs = false;
			this.partyNodes.Clear();
			this.partyBoatNodes.Clear();
			MasterAudio.PlaySound3DAtVector3AndForget("Splash", this.tr.position, Random.Range(0.8f, 1f), new float?(Random.Range(0.95f, 1f)), 0f, "", null);
			int partyCounts = 4;
			if (boroMovesToWater)
			{
				partyCounts = this.party.Count + 1;
			}
			else
			{
				partyCounts = this.party.Count;
			}
			constPath.Release(this, false);
			centerNode = Links.x.main.node;
			this.SetNodeConstraint(null, false);
			this.nodeConstraint.constrainWalkability = false;
			this.nodeConstraint.constrainToEnvironment = 1;
			ConstantPath constPath2 = ConstantPath.ConstructFast(centerNode, 20000, null);
			constPath2.nnConstraint = this.nodeConstraint;
			AstarPath.StartPath(constPath2, false);
			yield return base.StartCoroutine(constPath2.WaitForPath());
			constPath2.Claim(this);
			this.allNodes = constPath.allNodes;
			if (true)
			{
				int num8;
				for (int i = 0; i < partyCounts; i = num8 + 1)
				{
					num = this.allNodes.Count;
					Character sailor = null;
					if (i == this.party.Count)
					{
						sailor = Links.x.gaia.boro;
					}
					else
					{
						sailor = this.party[i];
					}
					Vector3 spot = this.standingSpots[i].position;
					this.nodeConstraint.constrainToEnvironment = 1;
					this.SetNodeConstraint(sailor, true);
					count = 0;
					this.suitableNodes.Clear();
					this.bestNodes.Clear();
					this.moveNodes.Clear();
					bool foundNode = false;
					if ((spot - sailor.tr.position).sqrMagnitude < 225f)
					{
						this.nodeConstraint.constrainToEnvironment = 2;
						this.nodeConstraint.checkConnections = sailor.ConnectionNumber();
						this.nodeConstraint.constrainWalkability = true;
						this.nodeConstraint.walkable = true;
						this.nodeConstraint.constrainTags = false;
						this.nodeConstraint.checkCircleID = 0;
						this.nodeConstraint.uniqueID = 0;
						this.nodeConstraint.passID = sailor.nodeStationaryID;
						this.nodeConstraint.passID2 = sailor.nodeMovingID;
						this.nodeConstraint.constrainPenalty = 0;
						this.nodeConstraint.constrainToArea = -1;
						GraphNode graphNode3 = Links.x.gaia.exteriorGraph.GetNearestForce(spot, this.nodeConstraint).node;
						if (graphNode3 != null)
						{
							this.partyBoatNodes.Add(graphNode3);
						}
						else
						{
							this.partyBoatNodes.Add(null);
						}
						this.partyNodes.Add(sailor.node);
						foundNode = true;
					}
					if (!foundNode)
					{
						this.nodeConstraint.constrainToEnvironment = 1;
						this.SetNodeConstraint(sailor, true);
						for (int num3 = num - 1; num3 >= 0; num3--)
						{
							GraphNode graphNode = this.allNodes[num3];
							if (this.SubtractVectors((Vector3)graphNode.position, spot).sqrMagnitude < 100f)
							{
								this.nodeConstraint.constrainTags = true;
								if (this.nodeConstraint.Suitable(graphNode))
								{
									this.moveNodes.Add(graphNode);
								}
							}
						}
					}
					int start = 0;
					for (int j = 0; j < 3; j = num8 + 1)
					{
						if (!foundNode)
						{
							for (int num4 = 0; num4 < 10; num4++)
							{
								if (!foundNode)
								{
									float num5 = float.PositiveInfinity;
									int num6 = -1;
									for (int num7 = 0; num7 < this.moveNodes.Count; num7++)
									{
										float sqrMagnitude2 = this.SubtractVectors((Vector3)this.moveNodes[num7].position, spot).sqrMagnitude;
										if (sqrMagnitude2 < num5)
										{
											bool flag2 = num4 == 0;
											if (num4 > 0 && !this.bestNodes.Contains(this.moveNodes[num7]))
											{
												flag2 = true;
											}
											if (flag2)
											{
												num5 = sqrMagnitude2;
												num6 = num7;
											}
										}
									}
									if (num6 > -1)
									{
										this.bestNodes.Add(this.moveNodes[num6]);
									}
								}
							}
							yield return new WaitForEndOfFrame();
							for (int k = start; k < this.bestNodes.Count; k = num8 + 1)
							{
								if (!foundNode)
								{
									ABPath p = ABPath.ConstructFast(sailor.node, this.bestNodes[k], null);
									this.nodeConstraint.constrainToEnvironment = 1;
									this.nodeConstraint.constrainTags = false;
									this.nodeConstraint.checkConnections = sailor.ConnectionNumber();
									p.nnConstraint = this.nodeConstraint;
									AstarPath.StartPath(p, false);
									yield return base.StartCoroutine(p.WaitForPath());
									p.Claim(this);
									num8 = count;
									count = num8 + 1;
									if (!p.error)
									{
										foundNode = true;
										this.partyNodes.Add(this.bestNodes[k]);
										this.nodeConstraint.constrainToEnvironment = 2;
										this.nodeConstraint.checkConnections = sailor.ConnectionNumber();
										this.nodeConstraint.constrainWalkability = true;
										this.nodeConstraint.walkable = true;
										this.nodeConstraint.constrainTags = false;
										this.nodeConstraint.uniqueID = 0;
										this.nodeConstraint.passID = sailor.nodeStationaryID;
										this.nodeConstraint.passID2 = sailor.nodeMovingID;
										this.nodeConstraint.constrainPenalty = 0;
										this.nodeConstraint.constrainToArea = -1;
										GraphNode graphNode4 = Links.x.gaia.exteriorGraph.GetNearestForce(spot, this.nodeConstraint).node;
										if (graphNode4 != null)
										{
											this.partyBoatNodes.Add(graphNode4);
										}
										else
										{
											this.partyBoatNodes.Add(null);
										}
									}
									p.Release(this, false);
									p = null;
								}
								num8 = k;
							}
							start = this.bestNodes.Count;
						}
						num8 = j;
					}
					if (!foundNode)
					{
						string text = "no node path for ";
						Character character = sailor;
						Debug.Log(text + ((character != null) ? character.ToString() : null));
						this.partyNodes.Add(sailor.node);
						this.nodeConstraint.constrainToEnvironment = 2;
						this.nodeConstraint.checkConnections = sailor.ConnectionNumber();
						this.nodeConstraint.constrainWalkability = true;
						this.nodeConstraint.walkable = true;
						this.nodeConstraint.constrainTags = false;
						this.nodeConstraint.uniqueID = 0;
						this.nodeConstraint.passID = sailor.nodeStationaryID;
						this.nodeConstraint.passID2 = sailor.nodeMovingID;
						this.nodeConstraint.constrainPenalty = 0;
						this.nodeConstraint.constrainToArea = -1;
						GraphNode graphNode5 = Links.x.gaia.exteriorGraph.GetNearestForce(spot, this.nodeConstraint).node;
						this.partyBoatNodes.Add(graphNode5);
					}
					sailor = null;
					spot = default(Vector3);
					num8 = i;
				}
			}
			constPath2.Release(this, false);
			this.nodeConstraint.constrainToEnvironment = 2;
			this.nodeConstraint.checkConnections = boro.ConnectionNumber();
			this.nodeConstraint.constrainWalkability = true;
			this.nodeConstraint.walkable = true;
			this.nodeConstraint.constrainTags = false;
			this.nodeConstraint.uniqueID = 0;
			this.nodeConstraint.passID = boro.nodeStationaryID;
			this.nodeConstraint.passID2 = boro.nodeMovingID;
			this.nodeConstraint.constrainPenalty = 0;
			this.nodeConstraint.constrainToArea = -1;
			GraphNode graphNode6 = Links.x.gaia.exteriorGraph.GetNearestForce(this.standingSpots[4].position, this.nodeConstraint).node;
			Links.x.gaia.boro.tr.position = this.standingSpots[4].position;
			Links.x.gaia.boro.FirstPosition(graphNode6);
			Links.x.gaia.boro.ToggleBoat(false);
			Links.x.gaia.boro.SetRotation(this.tr.rotation, false, true);
			Links.x.gaia.boro.stats.model = Records.x.GetBoroModel(Records.x.boroID, false, true);
			Links.x.gaia.boro.SetupBody();
			Links.x.gaia.boro.meshAlwaysOff = false;
			Links.x.gaia.boro.SetMeshState(true);
			Links.x.gaia.boro.body.SetMeshState(true, true);
			this.SetSailingState(Links.x.gaia.boro, true);
			Links.x.gaia.boro.ignoreRemoveControls = false;
			Links.x.gaia.boro.ignoreNodeIDs = false;
			Links.x.gaia.boro.ClearNodeIDs();
			MasterAudio.PlaySound3DAtVector3AndForget("Splash", this.tr.position, Random.Range(0.8f, 1f), new float?(Random.Range(0.95f, 1f)), 0f, "", null);
			Links.x.gaia.boro.tr.SetParent(this.tr, true);
			if (Links.x.gaia.boro.circleTr)
			{
				Links.x.gaia.boro.circleTr.SetParent(this.tr, true);
			}
			Links.x.gaia.boro.tr.position = this.standingSpots[4].position;
			if (boroMovesToWater)
			{
				while (this.animator.GetCurrentAnimatorStateInfo(0).normalizedTime < 0.5f)
				{
					yield return null;
				}
			}
			this.BoatFollow();
			int num9;
			if (boroMovesToWater)
			{
				num9 = this.party.Count + 1;
			}
			else
			{
				num9 = this.party.Count;
			}
			for (int num10 = 0; num10 < num9; num10++)
			{
				Character character2;
				if (num10 < this.party.Count)
				{
					character2 = this.party[num10];
				}
				else
				{
					character2 = Links.x.gaia.boro;
				}
				Vector3 position2 = this.standingSpots[num10].position;
				character2.ignoreRemoveControls = true;
				character2.ignoreNodeIDs = true;
				if (num10 < this.partyNodes.Count && this.partyNodes[num10] != null)
				{
					if (this.partyNodes[num10] != character2.node)
					{
						character2.MakePath(this.partyNodes[num10], 1000, false, false, true);
						this.states[num10] = "Moving";
					}
					else
					{
						this.states[num10] = "Moving";
					}
					this.stateTimes[num10] = Time.timeSinceLevelLoad;
				}
			}
			this.RemoveSummons(1);
			this.removeSummonsTime = Time.timeSinceLevelLoad;
			while (this.WaitingForPartyMovement(boroMovesToWater))
			{
				yield return null;
			}
			if (this.removeSummonsTime != 0f)
			{
				this.RemoveSummons(2);
				this.removeSummonsTime = 0f;
			}
			boro.FindCurrentNode(false);
			if (boro.circleTr)
			{
				boro.circleTr.gameObject.SetActive(false);
			}
			this.ReturnOarSplashes();
			this.sailors.Clear();
			for (int num11 = 0; num11 < this.party.Count; num11++)
			{
				if (this.party[num11] && !this.party[num11].summoned)
				{
					this.SetSailingState(this.party[num11], true);
					this.sailors.Add(this.party[num11]);
					this.AddOarSplash();
				}
			}
			this.ChangeTimeOfDay();
			this.sailing = true;
			Records.x.partySailing = true;
			Links.x.gaia.boro.boatNavigator = true;
			this.navigator = Links.x.gaia.boro;
			Links.x.gaia.boro.boat = this;
			rot = this.tr.rotation;
			this.smoothRot = rot;
			this.AddSplashes();
			Links.x.rtsCamera.Follow(Links.x.main.tr, Links.x.main, false);
			this.setup = true;
			Records.x.StartUIFade(false, false);
			Links.x.beachCollider.SetActive(true);
			Links.x.partyColliderAdventure.beachCollector.SwitchBeachCollider();
			this.noiseUpdateTime = Time.timeSinceLevelLoad;
			Links.x.rtsCamera.ToggleSailing();
			constPath2 = null;
		}
		Links.x.rtsCamera.ignoreRemoveControls = false;
		Links.x.gameplay.SetDomeSize();
		Records.x.RemoveControls(false);
		Records.x.holdCombat = false;
		this.startSailCoroutine = null;
		yield break;
	}

	// Token: 0x06000229 RID: 553 RVA: 0x0002EAF4 File Offset: 0x0002CCF4
	private bool WaitingForPartyMovement(bool boroMovesToWater)
	{
		bool flag = false;
		int num;
		if (boroMovesToWater)
		{
			num = this.party.Count + 1;
		}
		else
		{
			num = this.party.Count;
		}
		if (this.removeSummonsTime != 0f && Time.timeSinceLevelLoad > this.removeSummonsTime + 0.4f)
		{
			this.RemoveSummons(2);
			this.removeSummonsTime = 0f;
		}
		for (int i = 0; i < num; i++)
		{
			Character character;
			if (i < this.party.Count)
			{
				character = this.party[i];
			}
			else
			{
				character = Links.x.gaia.boro;
			}
			if (character)
			{
				if (this.states[i] != "Done")
				{
					if (this.states[i] == "NeedsNode" && !character.jumping)
					{
						this.SetSailingState(character, true);
						character.tr.position = Vector3.Lerp(character.tr.position, this.standingSpots[i].position, Time.deltaTime * 10f);
						if (!character.isBoro)
						{
							character.tr.rotation = this.standingSpots[i].rotation;
							character.rot = this.standingSpots[i].rotation;
							character.smoothRot = this.standingSpots[i].rotation;
						}
						character.ignoreRemoveControls = false;
						character.ignoreNodeIDs = false;
						character.ClearNodeIDs();
						this.states[i] = "Done";
						character.PlayAnimation("Idle", Random.Range(0f, 1f));
						MasterAudio.PlaySound3DAtVector3AndForget("Splash", this.tr.position, Random.Range(0.8f, 1f), new float?(Random.Range(0.95f, 1f)), 0f, "", null);
						if (character == Links.x.gaia.boro)
						{
							character.body.SetMeshState(false, true);
						}
					}
					else if (character.moving || character.waitingForNewPath)
					{
						flag = true;
						if (this.states[i] == "Repathing" && Time.timeSinceLevelLoad > this.stateTimes[i] + 1f)
						{
							this.states[i] = "Moving";
							this.stateTimes[i] = Time.timeSinceLevelLoad;
						}
					}
					else if (this.partyNodes[i] != null)
					{
						if ((character.tr.position - (Vector3)this.partyNodes[i].position).sqrMagnitude < 9f && (this.states[i] == "Repathing" || this.states[i] == "Moving"))
						{
							if (this.partyBoatNodes[i] != null)
							{
								if ((i == 4 && Time.timeSinceLevelLoad > this.stateTimes[i] + 0.01f) || i < 4)
								{
									character.TargetReached();
									character.ClearNodePath();
									this.SetSailingState(character, true);
									character.ignoreRemoveControls = true;
									character.ignoreNodeIDs = true;
									character.alwaysJump = true;
									character.Jump(this.partyBoatNodes[i], this.standingSpots[i].position, false, false);
									this.states[i] = "Jumping";
									this.stateTimes[i] = Time.timeSinceLevelLoad;
								}
								flag = true;
							}
							else
							{
								character.TargetReached();
								this.SetSailingState(character, true);
								character.tr.SetParent(this.tr, true);
								if (character.circleTr)
								{
									character.circleTr.SetParent(this.tr, true);
								}
								character.SetPosition(this.standingSpots[i].position, null);
								character.SetRotation(this.standingSpots[i].rotation, false, false);
								if (!character.isBoro)
								{
									character.tr.rotation = this.standingSpots[i].rotation;
									character.rot = this.standingSpots[i].rotation;
									character.smoothRot = this.standingSpots[i].rotation;
								}
								character.ClaimNode(null, character.tr.position, false);
								character.ignoreRemoveControls = false;
								character.ignoreNodeIDs = false;
								this.states[i] = "Done";
							}
						}
						else if (this.states[i] == "Jumping" && (Time.timeSinceLevelLoad > this.stateTimes[i] + 1f || (character.tr.position - this.standingSpots[i].position).sqrMagnitude < 0.0625f || ((character.tr.position - this.standingSpots[i].position).sqrMagnitude < 4f && !character.jumping)))
						{
							if (character.tr.parent != this.tr)
							{
								this.SetSailingState(character, true);
								character.tr.SetParent(this.tr, true);
								character.tr.position = Vector3.Lerp(character.tr.position, this.standingSpots[i].position, Time.deltaTime * 10f);
								if (character.circleTr)
								{
									character.circleTr.SetParent(this.tr, true);
								}
								this.states[i] = "NeedsNode";
								flag = true;
							}
						}
						else
						{
							if ((this.states[i] == "Moving" || this.states[i] == "Repathing") && Time.timeSinceLevelLoad > this.stateTimes[i] + 0.5f)
							{
								character.MakePath(this.partyNodes[i], 1000, false, false, true);
								this.states[i] = "Repathing";
								this.stateTimes[i] = Time.timeSinceLevelLoad;
							}
							flag = true;
						}
					}
					else
					{
						string[] array = new string[5];
						int num2 = 0;
						Character character2 = character;
						array[num2] = ((character2 != null) ? character2.ToString() : null);
						array[1] = " not moving node is: ";
						int num3 = 2;
						GraphNode graphNode = character.node;
						array[num3] = ((graphNode != null) ? graphNode.ToString() : null);
						array[3] = " to : ";
						int num4 = 4;
						GraphNode graphNode2 = this.partyNodes[i];
						array[num4] = ((graphNode2 != null) ? graphNode2.ToString() : null);
						Debug.Log(string.Concat(array));
						flag = true;
					}
				}
				else if (!character.isBoro && i < this.standingSpots.Length)
				{
					character.tr.position = Vector3.Lerp(character.tr.position, this.standingSpots[i].position, Time.deltaTime * 10f);
					if (!character.inAction)
					{
						character.SetRotation(this.standingSpots[i].rotation, false, true);
					}
				}
			}
		}
		Links.x.gaia.boro.SetPosition(this.standingSpots[4].position, null);
		Links.x.gaia.boro.SetRotation(this.standingSpots[4].rotation, false, true);
		return flag;
	}

	// Token: 0x0600022A RID: 554 RVA: 0x0002F214 File Offset: 0x0002D414
	public void GetOffBoat()
	{
		Debug.Log("Get off boat");
		if (this.startSailCoroutine == null)
		{
			base.enabled = true;
			this.startSailCoroutine = this.BoatToLand();
			base.StartCoroutine(this.startSailCoroutine);
			return;
		}
		if (Links.x.gaia.pathfindingReady)
		{
			Links.x.gameFeed.AddFeed("Busy");
		}
	}

	// Token: 0x0600022B RID: 555 RVA: 0x0002F279 File Offset: 0x0002D479
	private IEnumerator BoatToLand()
	{
		this.settingPosition = false;
		this.leavingBoat = true;
		Records.x.holdCombat = true;
		Records.x.RemoveControls(true);
		if (Records.x.paused)
		{
			Links.x.gameplay.TogglePause(false);
		}
		if (!this.tr)
		{
			this.tr = base.transform;
		}
		for (int j = 0; j < this.states.Length; j++)
		{
			this.states[j] = "";
		}
		Links.x.rtsCamera.ignoreRemoveControls = true;
		Links.x.rtsCamera.Follow(Links.x.main.tr, Links.x.main, false);
		bool foundSpot = false;
		Character boro = Links.x.gaia.boro;
		boro.TargetReached();
		this.movePoint = Vector3.zero;
		float radius = 15f;
		this.nodeConstraint.constrainWalkability = true;
		this.nodeConstraint.walkable = true;
		this.nodeConstraint.constrainTags = false;
		this.nodeConstraint.checkCircleID = 0;
		this.nodeConstraint.passID = 0;
		this.nodeConstraint.passID2 = 0;
		this.nodeConstraint.constrainPenalty = 0;
		this.nodeConstraint.checkConnections = 0;
		this.nodeConstraint.constrainToEnvironment = 1;
		this.nodeConstraint.constrainToArea = -1;
		GraphNode shoreNode = Links.x.gaia.exteriorGraph.GetNearestForce(this.tr.position, this.nodeConstraint).node;
		ConstantPath constPath = ConstantPath.ConstructFast(shoreNode, Records.x.GetConstantPathRadius((int)radius), null);
		this.SetNodeConstraint(null, true);
		this.nodeConstraint.constrainWalkability = false;
		this.nodeConstraint.constrainToEnvironment = 1;
		constPath.nnConstraint = this.nodeConstraint;
		AstarPath.StartPath(constPath, false);
		yield return base.StartCoroutine(constPath.WaitForPath());
		constPath.Claim(this);
		this.allNodes = constPath.allNodes;
		int num = this.allNodes.Count;
		Vector3 zero = Vector3.zero;
		Vector3 zero2 = Vector3.zero;
		Vector3 zero3 = Vector3.zero;
		Vector3 zero4 = Vector3.zero;
		Vector3 forward = Vector3.forward;
		Vector3 zero5 = Vector3.zero;
		Vector3 vector = Vector3.zero;
		this.SetNodeConstraint(boro, true);
		this.nodeConstraint.uniqueID = 0;
		this.nodeConstraint.checkConnections = this.connections;
		this.nodeConstraint.constrainToEnvironment = 1;
		this.nodeConstraint.constrainWalkability = true;
		this.suitableNodes.Clear();
		this.moveNodes.Clear();
		for (int k = 0; k < num; k++)
		{
			GraphNode graphNode = this.allNodes[k];
			if (((Vector3)graphNode.position - (Vector3)shoreNode.position).sqrMagnitude < radius * radius && this.nodeConstraint.Suitable(graphNode))
			{
				this.suitableNodes.Add(graphNode);
			}
		}
		num = this.suitableNodes.Count;
		int num2 = num - 1;
		Vector3 position = boro.tr.position;
		Vector3 vector2 = this.tr.rotation.eulerAngles;
		Quaternion quaternion = Quaternion.Euler(vector2);
		GraphNode boatTargetNode = null;
		for (int l = num2; l >= 0; l--)
		{
			if (!foundSpot)
			{
				GraphNode graphNode = this.suitableNodes[l];
				vector = (Vector3)graphNode.position;
				RaycastHit raycastHit;
				if (Physics.Raycast(vector + new Vector3(0f, 30f, 0f), Vector3.up * -1f, 60f, 16384) && Physics.Raycast(vector + new Vector3(0f, 30f, 0f), Vector3.up * -1f, out raycastHit, 60f, 4194321) && (raycastHit.collider.gameObject.layer == 3 || raycastHit.collider.gameObject.layer == 0))
				{
					boatTargetNode = graphNode;
					foundSpot = true;
					break;
				}
			}
		}
		if (boatTargetNode == null)
		{
			foundSpot = false;
			Links.x.gameFeed.AddFeed("The shore is blocked");
			Links.x.gameFeed.ShowNotice("The shore is blocked");
		}
		else
		{
			foundSpot = true;
			this.partyNodes.Clear();
			this.partyBoatNodes.Clear();
			boro.ClaimNode(boatTargetNode, (Vector3)boatTargetNode.position, true);
			for (int m = 0; m < this.party.Count; m++)
			{
				num = this.allNodes.Count;
				Character character = this.party[m];
				this.nodeConstraint.constrainToEnvironment = 1;
				Vector3 position2 = this.standingSpots[m].position;
				this.SetNodeConstraint(character, true);
				this.nodeConstraint.uniqueID = 1;
				this.nodeConstraint.constrainToEnvironment = 1;
				this.suitableNodes.Clear();
				this.bestNodes.Clear();
				this.moveNodes.Clear();
				for (int n = num - 1; n >= 0; n--)
				{
					GraphNode graphNode = this.allNodes[n];
					if (this.SubtractVectors((Vector3)graphNode.position, position2).sqrMagnitude < 400f)
					{
						this.nodeConstraint.constrainTags = true;
						if (this.nodeConstraint.Suitable(graphNode))
						{
							this.moveNodes.Add(graphNode);
						}
					}
				}
				float num3 = float.PositiveInfinity;
				int num4 = -1;
				for (int num5 = 0; num5 < this.moveNodes.Count; num5++)
				{
					float sqrMagnitude = this.SubtractVectors((Vector3)this.moveNodes[num5].position, position2).sqrMagnitude;
					if (sqrMagnitude < num3)
					{
						num3 = sqrMagnitude;
						num4 = num5;
					}
				}
				if (num4 > -1)
				{
					this.partyNodes.Add(this.moveNodes[num4]);
					this.moveNodes[num4].SetFlowerConnectionsPlanning(1, 1, 0);
				}
				else
				{
					Debug.Log("null nodes");
					this.partyNodes.Add(null);
				}
			}
			bool flag = true;
			for (int num6 = 0; num6 < this.party.Count; num6++)
			{
				if (this.partyNodes[num6] == null)
				{
					flag = false;
				}
			}
			for (int num7 = 0; num7 < this.partyNodes.Count; num7++)
			{
				if (this.partyNodes[num7] != null)
				{
					this.partyNodes[num7].SetFlowerConnectionsPlanning(1, 0, 0);
				}
			}
			if (!flag)
			{
				foundSpot = false;
				Links.x.gameFeed.AddFeed("The path to shore is blocked");
				Links.x.gameFeed.ShowNotice("The path to shore is blocked");
			}
		}
		constPath.Release(this, false);
		if (foundSpot)
		{
			Links.x.gaia.boro.boatNavigator = false;
			Records.x.StartUIFade(true, false);
			int num8;
			for (int i = 0; i < this.party.Count; i = num8 + 1)
			{
				Character character2 = this.party[i];
				character2.ignoreRemoveControls = true;
				character2.ignoreNodeIDs = true;
				if (this.partyNodes[i] != null)
				{
					character2.alwaysJump = true;
					character2.Jump(this.partyNodes[i], (Vector3)this.partyNodes[i].position, false, false);
					this.states[i] = "Jumping";
					this.stateTimes[i] = Time.timeSinceLevelLoad;
					character2.NeedToUpdateSailingAnimator(true);
					MasterAudio.PlaySound3DAtVector3AndForget("Splash", this.tr.position, Random.Range(0.8f, 1f), new float?(Random.Range(0.95f, 1f)), 0f, "", null);
				}
				yield return new WaitForSeconds(0.1f);
				num8 = i;
			}
			this.t = 0f;
			this.startDither = 1f;
			this.endDither = 0f;
			while (this.WaitingForPartyMovementOffBoat())
			{
				yield return null;
			}
			this.RemoveBoatNode();
			MasterAudio.PlaySound3DAtVector3AndForget("Splash", this.tr.position, Random.Range(0.8f, 1f), new float?(Random.Range(0.95f, 1f)), 0f, "", null);
			boro.tr.SetParent(Links.x.gameplay.transform);
			boro.tr.SetParent(null);
			if (boro.circleTr)
			{
				boro.circleTr.SetParent(Links.x.gameplay.gameObject.transform, true);
			}
			Links.x.gaia.boro.stats.model = Records.x.GetBoroModel(Records.x.boroID, true, false);
			Links.x.gaia.boro.SetupBody();
			boro.SetMeshState(false);
			boro.body.SetMeshState(false, false);
			yield return new WaitForSeconds(0.01f);
			boro.SetMeshState(true);
			vector2 = Quaternion.LookRotation(boro.tr.position - this.tr.position).eulerAngles;
			vector2.y += 87f;
			vector2.x = 0f;
			vector2.z = 0f;
			Quaternion quaternion2 = Quaternion.Euler(vector2);
			this.SetSailingState(boro, false);
			boro.ToggleBoat(true);
			boro.SetRotation(quaternion2, false, true);
			boro.SetPosition((Vector3)boatTargetNode.position, boatTargetNode);
			boro.FirstPosition(null);
			boro.ignoreRemoveControls = false;
			boro.ignoreNodeIDs = false;
			this.rbody.isKinematic = true;
			if (this.useBuoyancy)
			{
				this.bouyancy.enabled = false;
			}
			if (boro.circleTr)
			{
				boro.circleTr.gameObject.SetActive(true);
			}
			Records.x.boroLastBeachPoint = boro.tr.position;
			this.ReturnOarSplashes();
			this.sailors.Clear();
			this.sailing = false;
			this.ReturnSplashes();
			Records.x.StartUIFade(false, false);
			boro.body.SetMeshState(true, false);
			this.SetSailingState(boro, false);
			for (int num9 = 0; num9 < this.party.Count; num9++)
			{
				this.party[num9].sailing = false;
				this.party[num9].NeedToUpdateSailingAnimator(true);
			}
			Records.x.partySailing = false;
			Links.x.partyColliderAdventure.beachCollector.SwitchBeachCollider();
			Links.x.rtsCamera.ToggleSailing();
			this.ReturnSummons(this.partyNodes[0]);
		}
		Links.x.rtsCamera.ignoreRemoveControls = false;
		Records.x.holdCombat = false;
		Records.x.RemoveControls(false);
		this.startSailCoroutine = null;
		Links.x.gameplay.SetDomeSize();
		if (foundSpot)
		{
			base.gameObject.SetActive(false);
		}
		this.leavingBoat = false;
		yield break;
	}

	// Token: 0x0600022C RID: 556 RVA: 0x0002F288 File Offset: 0x0002D488
	private bool WaitingForPartyMovementOffBoat()
	{
		bool flag = false;
		for (int i = 0; i < this.party.Count; i++)
		{
			Character character = this.party[i];
			if (character && this.states[i] != "Done")
			{
				if (this.states[i] == "NeedsNode" && !character.jumping)
				{
					character.tr.SetParent(Links.x.gameplay.transform);
					character.tr.SetParent(null);
					if (character.circleTr)
					{
						character.circleTr.SetParent(Links.x.gameplay.gameObject.transform, true);
					}
					this.SetSailingState(character, false);
					character.ignoreRemoveControls = false;
					character.ignoreNodeIDs = false;
					this.states[i] = "Done";
				}
				else if (character.moving || character.waitingForNewPath)
				{
					flag = true;
					if (this.states[i] == "Repathing" && Time.timeSinceLevelLoad > this.stateTimes[i] + 1f)
					{
						this.states[i] = "Jumping";
						this.stateTimes[i] = Time.timeSinceLevelLoad;
					}
				}
				else if (character.node != null && this.partyNodes[i] != null)
				{
					if (((Vector3)character.node.position - (Vector3)this.partyNodes[i].position).sqrMagnitude < 4f && (this.states[i] == "Repathing" || this.states[i] == "Jumping"))
					{
						if (character.tr.parent == this.tr)
						{
							this.states[i] = "NeedsNode";
							flag = true;
						}
					}
					else
					{
						if ((this.states[i] == "Jumping" || this.states[i] == "Repathing") && Time.timeSinceLevelLoad > this.stateTimes[i] + 1f)
						{
							this.SetSailingState(character, false);
							character.alwaysJump = true;
							character.Jump(this.partyNodes[i], (Vector3)this.partyNodes[i].position, false, false);
							this.states[i] = "Repathing";
							this.stateTimes[i] = Time.timeSinceLevelLoad;
						}
						flag = true;
					}
				}
				else
				{
					flag = true;
				}
			}
		}
		return flag;
	}

	// Token: 0x0600022D RID: 557 RVA: 0x0002F520 File Offset: 0x0002D720
	public void ChangeScenes(Vector3 exitPoint)
	{
		this.tr.position = exitPoint;
		this.ResetNode();
		if (this.node != null)
		{
			this.tr.position = (Vector3)this.node.position;
			exitPoint = (Vector3)this.node.position;
		}
		this.settingPosition = true;
		base.StartCoroutine(this.SetPosition(exitPoint));
	}

	// Token: 0x0600022E RID: 558 RVA: 0x0002F589 File Offset: 0x0002D789
	private IEnumerator SetPosition(Vector3 pt)
	{
		this.rbody.isKinematic = true;
		float timeToLerp = 0.25f;
		float percentage = 0f;
		float startTime = Time.time;
		while (percentage < 1f && this.settingPosition)
		{
			percentage = (Time.time - startTime) / timeToLerp;
			this.tr.position = pt;
			this.boatFollow.position = this.tr.position;
			yield return null;
		}
		this.rbody.isKinematic = false;
		this.settingPosition = false;
		yield break;
	}

	// Token: 0x0600022F RID: 559 RVA: 0x0002F5A0 File Offset: 0x0002D7A0
	public void PartySetupFromLoad()
	{
		this.party = Links.x.portraitOrder;
		this.boat.SetActive(true);
		this.animator.Play(this.animationOpenName, 0, 1f);
		base.StartCoroutine(this.ParytSetupFromLoadFinish());
		this.noiseUpdateTime = Time.timeSinceLevelLoad;
	}

	// Token: 0x06000230 RID: 560 RVA: 0x0002F5F8 File Offset: 0x0002D7F8
	private IEnumerator ParytSetupFromLoadFinish()
	{
		this.settingPosition = false;
		yield return new WaitForSeconds(0.05f);
		while (!Links.x.gaia.boro)
		{
			yield return null;
		}
		for (int i = 0; i < this.party.Count + 1; i++)
		{
			Character character;
			if (i == 4)
			{
				character = Links.x.gaia.boro;
			}
			else
			{
				if (this.party[i])
				{
					this.sailors.Add(this.party[i]);
					this.AddOarSplash();
				}
				character = this.party[i];
			}
			if (character)
			{
				this.SetSailingState(character, true);
				character.SetPosition(this.standingSpots[i].position, null);
				character.tr.rotation = this.standingSpots[i].rotation;
				character.rot = this.standingSpots[i].rotation;
				character.smoothRot = this.standingSpots[i].rotation;
				character.ClaimNode(null, character.tr.position, false);
				character.tr.SetParent(this.tr, true);
				if (character.circleTr)
				{
					character.circleTr.SetParent(this.tr, true);
				}
				character.ClearNodeIDs();
			}
		}
		Links.x.gaia.boro.SetMeshState(true);
		this.sailing = true;
		float timeToLerp = 0.25f;
		float percentage = 0f;
		float startTime = Time.time;
		while (percentage < 1f)
		{
			percentage = (Time.time - startTime) / timeToLerp;
			this.tr.position = Records.x.boatPosition;
			this.tr.rotation = this.rot;
			this.boatFollow.position = this.tr.position;
			yield return null;
		}
		this.boat.SetActive(true);
		this.rbody.isKinematic = false;
		this.rbody.useGravity = true;
		timeToLerp = 0.5f;
		percentage = 0f;
		startTime = Time.time;
		while (percentage < 0.25f)
		{
			percentage = (Time.time - startTime) / timeToLerp;
			this.tr.position = Records.x.boatPosition;
			this.tr.rotation = this.rot;
			this.boatFollow.position = this.tr.position;
			yield return null;
		}
		this.rbody.isKinematic = false;
		if (this.useBuoyancy)
		{
			this.bouyancy.enabled = true;
		}
		Records.x.partySailing = true;
		Links.x.partyColliderAdventure.beachCollector.SwitchBeachCollider();
		Links.x.rtsCamera.ToggleSailing();
		this.AddSplashes();
		this.nodeConstraint.constrainToEnvironment = 2;
		this.nodeConstraint.checkConnections = this.connections;
		this.nodeConstraint.constrainWalkability = true;
		this.nodeConstraint.walkable = true;
		this.nodeConstraint.constrainTags = true;
		this.nodeConstraint.checkCircleID = 0;
		this.nodeStationaryID = Records.x.currentPathNode;
		this.nodeMovingID = this.nodeStationaryID + 100;
		this.nodeConstraint.passID = this.nodeStationaryID;
		this.nodeConstraint.passID2 = this.nodeMovingID;
		this.nodeConstraint.constrainPenalty = 0;
		this.nodeConstraint.constrainToArea = -1;
		this.node = Links.x.gaia.exteriorGraph.GetNearestForce(this.tr.position, this.nodeConstraint).node;
		this.lastNode = this.node;
		this.SetNodeID(false, false);
		Links.x.gaia.boro.boatNavigator = true;
		this.navigator = Links.x.gaia.boro;
		Links.x.gaia.boro.boat = this;
		if (Links.x.gaia.boro.circleTr)
		{
			Links.x.gaia.boro.circleTr.gameObject.SetActive(false);
		}
		Links.x.gaia.boro.ToggleBoat(false);
		this.rot = this.tr.rotation;
		this.smoothRot = this.rot;
		this.setup = true;
		this.rbody.useGravity = true;
		Links.x.beachCollider.SetActive(true);
		this.ChangeTimeOfDay();
		Links.x.gameplay.SetDomeSize();
		yield break;
	}

	// Token: 0x06000231 RID: 561 RVA: 0x0002F608 File Offset: 0x0002D808
	public void RemoveBoat()
	{
		if (this)
		{
			this.sailing = false;
			this.turning = false;
			this.rotating = false;
			this.navigator = null;
			this.ReturnOarSplashes();
			this.sailors.Clear();
			this.movePoint = Vector3.zero;
			this.ReturnSplashes();
			if (base.gameObject)
			{
				base.gameObject.SetActive(false);
				Links.x.archives.RecycleBoat(base.gameObject, this.model, "");
			}
		}
	}

	// Token: 0x06000232 RID: 562 RVA: 0x0002F694 File Offset: 0x0002D894
	public void ClearPartyBoat()
	{
		this.rbody.isKinematic = true;
		this.sailing = false;
		this.turning = false;
		this.rotating = false;
		this.navigator = null;
		this.ReturnOarSplashes();
		this.sailors.Clear();
		this.movePoint = Vector3.zero;
		this.ReturnSplashes();
		this.setup = false;
		base.gameObject.SetActive(false);
	}

	// Token: 0x06000233 RID: 563 RVA: 0x0002F6FE File Offset: 0x0002D8FE
	public void ClearBoatForRespawn()
	{
		this.sailing = false;
		this.turning = false;
		this.rotating = false;
		this.navigator = null;
		this.ReturnOarSplashes();
		this.sailors.Clear();
		this.movePoint = Vector3.zero;
		this.ReturnSplashes();
	}

	// Token: 0x06000234 RID: 564 RVA: 0x0002F73E File Offset: 0x0002D93E
	public void NPCSetupFromLoad(Vector3 pt, Quaternion r)
	{
		this.ClearBoatForRespawn();
		Links.x.ChangeBoatList(this, true);
		this.boat.SetActive(true);
		base.StartCoroutine(this.NPCSetupFromLoadFinish(pt, r));
	}

	// Token: 0x06000235 RID: 565 RVA: 0x0002F76D File Offset: 0x0002D96D
	private IEnumerator NPCSetupFromLoadFinish(Vector3 pt, Quaternion r)
	{
		yield return new WaitForSeconds(0.05f);
		this.settingPosition = false;
		this.sailing = true;
		float timeToLerp = 0.25f;
		float percentage = 0f;
		float startTime = Time.time;
		while (percentage < 1f)
		{
			percentage = (Time.time - startTime) / timeToLerp;
			this.tr.position = pt;
			this.tr.rotation = r;
			yield return null;
		}
		this.boat.SetActive(true);
		this.rbody.isKinematic = false;
		this.rbody.useGravity = true;
		timeToLerp = 0.5f;
		percentage = 0f;
		startTime = Time.time;
		while (percentage < 0.25f)
		{
			percentage = (Time.time - startTime) / timeToLerp;
			this.tr.position = pt;
			this.tr.rotation = r;
			yield return null;
		}
		this.nodeConstraint.constrainToEnvironment = 2;
		this.nodeConstraint.checkConnections = this.connections;
		this.nodeConstraint.constrainWalkability = true;
		this.nodeConstraint.walkable = true;
		this.nodeConstraint.constrainTags = true;
		this.nodeStationaryID = Records.x.currentPathNode;
		this.nodeMovingID = this.nodeStationaryID + 100;
		this.nodeConstraint.passID = this.nodeStationaryID;
		this.nodeConstraint.passID2 = this.nodeMovingID;
		this.nodeConstraint.constrainPenalty = 0;
		this.nodeConstraint.constrainToArea = -1;
		this.node = Links.x.gaia.exteriorGraph.GetNearestForce(this.tr.position, this.nodeConstraint).node;
		this.lastNode = this.node;
		this.SetNodeID(false, false);
		this.noiseUpdateTime = Time.timeSinceLevelLoad;
		this.ChangeTimeOfDay();
		this.AddSplashes();
		this.rot = this.tr.rotation;
		this.smoothRot = this.rot;
		this.rbody.useGravity = true;
		for (int i = 0; i < this.sailors.Count; i++)
		{
			this.sailors[i].NeedToUpdateSailingAnimator(true);
		}
		yield break;
	}

	// Token: 0x06000236 RID: 566 RVA: 0x0002F78A File Offset: 0x0002D98A
	public void TimeJump(Vector3 pt, Quaternion r)
	{
		base.StartCoroutine(this.TimeJumpWait(pt, r));
	}

	// Token: 0x06000237 RID: 567 RVA: 0x0002F79B File Offset: 0x0002D99B
	private IEnumerator TimeJumpWait(Vector3 pt, Quaternion r)
	{
		this.nodeConstraint.constrainToEnvironment = 2;
		this.nodeConstraint.checkConnections = this.connections;
		this.nodeConstraint.constrainWalkability = true;
		this.nodeConstraint.walkable = true;
		this.nodeConstraint.constrainTags = true;
		this.nodeStationaryID = Records.x.currentPathNode;
		this.nodeMovingID = this.nodeStationaryID + 100;
		this.nodeConstraint.passID = this.nodeStationaryID;
		this.nodeConstraint.passID2 = this.nodeMovingID;
		this.nodeConstraint.constrainPenalty = 0;
		this.nodeConstraint.constrainToArea = -1;
		GraphNode graphNode = Links.x.gaia.exteriorGraph.GetNearestForce(pt, this.nodeConstraint).node;
		if (graphNode != null)
		{
			this.node = graphNode;
			this.lastNode = this.node;
			pt = (Vector3)graphNode.position;
			float timeToLerp = 0.25f;
			float percentage = 0f;
			float startTime = Time.time;
			while (percentage < 1f)
			{
				percentage = (Time.time - startTime) / timeToLerp;
				this.tr.position = pt;
				this.tr.rotation = r;
				yield return null;
			}
			timeToLerp = 0.5f;
			percentage = 0f;
			startTime = Time.time;
			while (percentage < 0.25f)
			{
				percentage = (Time.time - startTime) / timeToLerp;
				this.tr.position = pt;
				this.tr.rotation = r;
				yield return null;
			}
			this.SetNodeID(false, false);
			this.ChangeTimeOfDay();
			this.rot = this.tr.rotation;
			this.smoothRot = this.rot;
			this.rbody.useGravity = true;
		}
		yield break;
	}

	// Token: 0x06000238 RID: 568 RVA: 0x0002F7B8 File Offset: 0x0002D9B8
	public void AddSailor(Character sailor, int i)
	{
		if (!this.navigator)
		{
			this.SetBoatNavigator(sailor, true);
		}
		this.sailors.Add(sailor);
		this.AddOarSplash();
		if (sailor)
		{
			this.SetSailingState(sailor, true);
			sailor.SetPosition(this.standingSpots[i].position, null);
			sailor.tr.rotation = this.standingSpots[i].rotation;
			sailor.rot = this.standingSpots[i].rotation;
			sailor.smoothRot = this.standingSpots[i].rotation;
			sailor.ClaimNode(null, sailor.tr.position, false);
			sailor.tr.SetParent(this.tr, true);
			if (sailor.circleTr)
			{
				sailor.circleTr.SetParent(this.tr, true);
			}
			sailor.ClearNodeIDs();
			sailor.NeedToUpdateSailingAnimator(true);
		}
	}

	// Token: 0x06000239 RID: 569 RVA: 0x0002F8A4 File Offset: 0x0002DAA4
	public void SetBoatNavigator(Character sailor, bool fromLoad)
	{
		if (sailor)
		{
			this.sailing = true;
			sailor.boatNavigator = true;
			this.navigator = sailor;
			sailor.boat = this;
			return;
		}
		bool flag = false;
		this.navigator = null;
		for (int i = 0; i < this.sailors.Count; i++)
		{
			if (this.sailors[i] && !flag && !this.sailors[i].dead && !this.sailors[i].stunned)
			{
				this.sailors[i].boatNavigator = true;
				this.navigator = this.sailors[i];
				this.sailors[i].boat = this;
				if (!fromLoad)
				{
					MasterAudio.PlaySound3DAtVector3AndForget("Splash", this.tr.position, Random.Range(0.8f, 1f), new float?(Random.Range(0.95f, 1f)), 0f, "", null);
				}
				flag = true;
			}
		}
		if (!flag)
		{
			for (int j = 0; j < this.sailors.Count; j++)
			{
				if (this.sailors[j] && !flag && !this.sailors[j].dead)
				{
					this.sailors[j].boatNavigator = true;
					this.navigator = this.sailors[j];
					this.sailors[j].boat = this;
					flag = true;
				}
			}
		}
		this.sailing = flag;
		if (!flag)
		{
			this.rotating = false;
			this.turning = false;
			if (!fromLoad)
			{
				this.AllDead();
			}
		}
	}

	// Token: 0x0600023A RID: 570 RVA: 0x0002FA68 File Offset: 0x0002DC68
	public bool IsSailorLeft(Character sailor)
	{
		if (sailor.party)
		{
			int num = this.party.IndexOf(sailor);
			if (num > -1 && num < this.rowLeft.Length)
			{
				return this.rowLeft[num];
			}
		}
		else if (sailor.npc)
		{
			int num2 = this.sailors.IndexOf(sailor);
			if (num2 > -1 && num2 < this.rowLeft.Length)
			{
				return this.rowLeft[num2];
			}
		}
		return false;
	}

	// Token: 0x0600023B RID: 571 RVA: 0x0002FAD0 File Offset: 0x0002DCD0
	public void PlayOarSplash(Character sailor)
	{
		int num = -1;
		if (sailor.party)
		{
			num = this.party.IndexOf(sailor);
		}
		else if (sailor.npc)
		{
			num = this.sailors.IndexOf(sailor);
		}
		if (num > -1 && num < this.oarSplashes.Count)
		{
			GameObject gameObject = this.oarSplashes[num];
			Vector3 position = sailor.oar.transform.position;
			position.y = Links.x.diorama.waterY + 0.6f;
			gameObject.transform.position = position;
			gameObject.SetActive(true);
			foreach (ParticleSystem particleSystem in gameObject.GetComponentsInChildren<ParticleSystem>(true))
			{
				particleSystem.Clear();
				particleSystem.Play();
			}
		}
	}

	// Token: 0x0600023C RID: 572 RVA: 0x0002FB8C File Offset: 0x0002DD8C
	private void ReturnOarSplashes()
	{
		for (int i = 0; i < this.oarSplashes.Count; i++)
		{
			if (this.oarSplashes[i])
			{
				Links.x.cellar.ReturnPooledGameObject(140, this.oarSplashes[i]);
			}
		}
		this.oarSplashes.Clear();
	}

	// Token: 0x0600023D RID: 573 RVA: 0x0002FBF0 File Offset: 0x0002DDF0
	private void AddOarSplash()
	{
		GameObject pooledGameObject = Links.x.cellar.GetPooledGameObject(140);
		pooledGameObject.SetActive(false);
		pooledGameObject.transform.parent = this.tr;
		pooledGameObject.transform.parent = null;
		this.oarSplashes.Add(pooledGameObject);
	}

	// Token: 0x0600023E RID: 574 RVA: 0x0002FC44 File Offset: 0x0002DE44
	private void AddSplashes()
	{
		if (!this.splashBack)
		{
			GameObject pooledGameObject = Links.x.cellar.GetPooledGameObject(138);
			pooledGameObject.SetActive(false);
			pooledGameObject.transform.parent = this.tr;
			pooledGameObject.transform.parent = null;
			this.splashBack = pooledGameObject;
			foreach (object obj in pooledGameObject.transform)
			{
				ParticleSystem component = ((Transform)obj).gameObject.GetComponent<ParticleSystem>();
				if (component)
				{
					this.splashParticles.Add(component);
				}
			}
		}
		if (!this.splashFront)
		{
			GameObject pooledGameObject2 = Links.x.cellar.GetPooledGameObject(139);
			pooledGameObject2.SetActive(false);
			pooledGameObject2.transform.parent = this.tr;
			pooledGameObject2.transform.parent = null;
			this.splashFront = pooledGameObject2;
			foreach (object obj2 in pooledGameObject2.transform)
			{
				ParticleSystem component2 = ((Transform)obj2).gameObject.GetComponent<ParticleSystem>();
				if (component2)
				{
					this.splashParticles.Add(component2);
				}
			}
		}
	}

	// Token: 0x0600023F RID: 575 RVA: 0x0002FDBC File Offset: 0x0002DFBC
	private void ReturnSplashes()
	{
		this.splashParticles.Clear();
		if (this.splashBack)
		{
			Links.x.cellar.ReturnPooledGameObject(138, this.splashBack);
			this.splashBack = null;
		}
		if (this.splashFront)
		{
			Links.x.cellar.ReturnPooledGameObject(139, this.splashFront);
			this.splashFront = null;
		}
	}

	// Token: 0x06000240 RID: 576 RVA: 0x0002FE30 File Offset: 0x0002E030
	public void OpenBag()
	{
		Links.x.characterSheet.merchant = true;
		Links.x.characterSheet.blacksmith = false;
		Links.x.characterSheet.pagan = false;
		Links.x.merchant.isBoat = true;
		Links.x.merchant.boat = this;
		Links.x.merchant.merchantCharacter = null;
		Links.x.merchant.creature = this.leadCreature;
		Links.x.characterSheet.peddler = this.model;
		Links.x.merchant.SetUpItems();
		Links.x.characterSheet.boat = this;
		Links.x.characterSheet.StartMenu(false);
	}

	// Token: 0x06000241 RID: 577 RVA: 0x0002FEF8 File Offset: 0x0002E0F8
	public void AllDead()
	{
		this.RemoveBoatNode();
		if (!base.gameObject.GetComponent<SelectionCircle>())
		{
			base.gameObject.AddComponent<SelectionCircle>().boat = this;
		}
		this.ReturnSplashes();
		this.ReturnOarSplashes();
		base.gameObject.layer = 19;
	}

	// Token: 0x06000242 RID: 578 RVA: 0x0002FF48 File Offset: 0x0002E148
	public void NewNPC()
	{
		if (base.gameObject.layer == 19)
		{
			for (int i = 0; i < this.sailors.Count; i++)
			{
				if (this.sailors[i] && this.sailors[i].body)
				{
					this.sailors[i].body.EndDead(2);
				}
			}
			this.sailors.Clear();
			this.ClearBoatForRespawn();
			Links.x.ChangeBoatList(this, true);
			this.boat.SetActive(true);
			this.sailing = true;
			this.boat.SetActive(true);
			this.rbody.isKinematic = false;
			this.rbody.useGravity = true;
			this.RemoveBoatNode();
			this.nodeConstraint.constrainToEnvironment = 2;
			this.nodeConstraint.checkConnections = this.connections;
			this.nodeConstraint.constrainWalkability = true;
			this.nodeConstraint.walkable = true;
			this.nodeConstraint.constrainTags = true;
			this.nodeStationaryID = Records.x.currentPathNode;
			this.nodeMovingID = this.nodeStationaryID + 100;
			this.nodeConstraint.passID = this.nodeStationaryID;
			this.nodeConstraint.passID2 = this.nodeMovingID;
			this.nodeConstraint.constrainPenalty = 0;
			this.nodeConstraint.constrainToArea = -1;
			this.node = Links.x.gaia.exteriorGraph.GetNearestForce(this.tr.position, this.nodeConstraint).node;
			this.lastNode = this.node;
			this.SetNodeID(false, false);
			this.noiseUpdateTime = Time.timeSinceLevelLoad;
			this.AddSplashes();
			this.rot = this.tr.rotation;
			this.smoothRot = this.rot;
			this.rbody.useGravity = true;
			base.gameObject.layer = 18;
		}
	}

	// Token: 0x06000243 RID: 579 RVA: 0x0003013E File Offset: 0x0002E33E
	public void EndStunNPC()
	{
	}

	// Token: 0x06000244 RID: 580 RVA: 0x00030140 File Offset: 0x0002E340
	public void AddSounds()
	{
		for (int i = 0; i < this.sailors.Count; i++)
		{
			if (this.sailors[i] && this.sailors[i].IsSentient())
			{
				Links.x.sensory.AddFootstep(this.sailors[i]);
			}
		}
	}

	// Token: 0x06000245 RID: 581 RVA: 0x000301A4 File Offset: 0x0002E3A4
	public void RemoveSummons(int pass)
	{
		this.allParty = Links.x.party;
		for (int i = 0; i < this.allParty.Count; i++)
		{
			Character character = this.allParty[i];
			if (character && character.summoned && !character.pipeSummons)
			{
				if (pass == 1)
				{
					character.meshAlwaysOff = true;
					character.SetMeshState(false);
					character.TargetReached();
				}
				else if (pass == 2)
				{
					character.RemoveLastNode(true);
					character.TurnScriptsOff();
				}
			}
		}
	}

	// Token: 0x06000246 RID: 582 RVA: 0x00030228 File Offset: 0x0002E428
	public void ReturnSummons(GraphNode n)
	{
		this.allParty = Links.x.party;
		for (int i = 0; i < this.allParty.Count; i++)
		{
			Character character = this.allParty[i];
			if (character && character.summoned && !character.dead && !character.pipeSummons)
			{
				GraphNode formationPosition = Links.x.fellowship.GetFormationPosition(n, character, false);
				if (formationPosition != null)
				{
					character.tr.position = (Vector3)formationPosition.position;
					character.FirstPosition(formationPosition);
				}
				else
				{
					float num = (float)i - 3f;
					num /= 2f;
					if (num > 3f)
					{
						num = 3f;
					}
					if (Random.Range(0, 2) == 0)
					{
						num *= -1f;
					}
					float num2 = num;
					if (Random.Range(0, 2) == 0)
					{
						num2 *= -1f;
					}
					character.tr.position = Links.x.main.tr.position + new Vector3(num, 0f, num);
					character.FirstPosition(null);
				}
				character.meshAlwaysOff = false;
				character.SetMeshState(true);
				character.TurnScriptsOn();
			}
		}
	}

	// Token: 0x06000247 RID: 583 RVA: 0x00030360 File Offset: 0x0002E560
	public void SetSailingState(Character character, bool state)
	{
		character.sailing = state;
		character.body.SetMagicaClothMode();
		character.NeedToUpdateSailingAnimator(true);
		character.stats.UpdateAbilityTriggers();
	}

	// Token: 0x06000248 RID: 584 RVA: 0x00030388 File Offset: 0x0002E588
	public void EndCombat()
	{
		for (int i = 0; i < this.sailors.Count; i++)
		{
			if (this.sailors[i] && this.sailors[i].hasActions)
			{
				this.sailors[i].actions.EndActions();
			}
		}
		this.ResetNode();
	}

	// Token: 0x06000249 RID: 585 RVA: 0x000303ED File Offset: 0x0002E5ED
	public void ResetNode()
	{
		this.RemoveBoatNode();
		this.ClaimNode(null, Vector3.zero, false);
	}

	// Token: 0x0600024A RID: 586 RVA: 0x00030404 File Offset: 0x0002E604
	public void ChangeTimeOfDay()
	{
		if (this.navigator || this.partyBoat)
		{
			if (!Links.x.gameplay.IsDay())
			{
				for (int i = 0; i < this.nightObjects.Length; i++)
				{
					if (!this.nightObjects[i].activeSelf)
					{
						this.nightObjects[i].SetActive(true);
					}
				}
				for (int j = 0; j < this.dayObjects.Length; j++)
				{
					if (this.dayObjects[j].activeSelf)
					{
						this.dayObjects[j].SetActive(false);
					}
				}
				return;
			}
			for (int k = 0; k < this.nightObjects.Length; k++)
			{
				if (this.nightObjects[k].activeSelf)
				{
					this.nightObjects[k].SetActive(false);
				}
			}
			for (int l = 0; l < this.dayObjects.Length; l++)
			{
				if (!this.dayObjects[l].activeSelf)
				{
					this.dayObjects[l].SetActive(true);
				}
			}
		}
	}

	// Token: 0x0600024B RID: 587 RVA: 0x000304FC File Offset: 0x0002E6FC
	public void ZeroPreviousNode()
	{
		this.CheckForNodeID();
		if (this.lastNode != null && this.lastNode != this.node)
		{
			this.lastNode.SetFlowerConnections(0, this.nodeMovingID, this.connections);
			this.lastNode.SetFlowerConnections(0, this.nodeStationaryID, this.connections);
		}
		this.lastNode = null;
	}

	// Token: 0x0600024C RID: 588 RVA: 0x0003055C File Offset: 0x0002E75C
	public void RemoveBoatNode()
	{
		this.CheckForNodeID();
		this.ZeroPreviousNode();
		this.lastNode = null;
		if (this.node != null)
		{
			this.node.SetFlowerConnections(0, this.nodeMovingID, this.connections);
			this.node.SetFlowerConnections(0, this.nodeStationaryID, this.connections);
		}
		this.node = null;
	}

	// Token: 0x0600024D RID: 589 RVA: 0x000305BC File Offset: 0x0002E7BC
	public void CheckInTile()
	{
		if (!Links.x.gaia.sceneLoaded)
		{
			return;
		}
		this.CheckForNodeID();
		if (this.node != null)
		{
			float sqrMagnitude = ((Vector3)this.node.position - this.tr.position).sqrMagnitude;
			GraphNode graphNode = this.node;
			float num = Records.x.nodeSize * Records.x.nodeSize;
			if (this.navigator && sqrMagnitude > num && !this.navigator.moving && this.navigator.NodesCount() == 0 && this.navigator.blockedTime == 0f && !this.navigator.waitingForNewPath)
			{
				GraphNode graphNode2 = this.NearNode(this.tr.position, true, 0, -1);
				if (graphNode2 != null)
				{
					this.ClaimNode(graphNode2, (Vector3)graphNode2.position, false);
				}
			}
		}
	}

	// Token: 0x0600024E RID: 590 RVA: 0x000306A8 File Offset: 0x0002E8A8
	public void ClaimNode(GraphNode curr, Vector3 pos, bool snap)
	{
		if (Links.x.gaia.noAstar)
		{
			Debug.Log("no astar");
			return;
		}
		this.CheckForNodeID();
		if (curr == null && pos != Vector3.zero)
		{
			GraphNode graphNode = this.NearNode(pos, true, 0, -1);
			if (graphNode != null)
			{
				if (this.node != graphNode)
				{
				}
				this.node = graphNode;
				pos = (Vector3)graphNode.position;
			}
			else
			{
				this.RemoveBoatNode();
				this.node = null;
			}
		}
		if (curr == null && pos == Vector3.zero)
		{
			if (this.tr.position != Vector3.zero)
			{
				this.node = this.NearNode(this.tr.position, true, 0, -1);
				if (this.node != null)
				{
					pos = (Vector3)this.node.position;
				}
			}
			else
			{
				this.RemoveBoatNode();
				this.node = null;
			}
		}
		if (curr != null)
		{
			if (this.node != curr)
			{
			}
			this.node = curr;
		}
		this.ZeroPreviousNode();
		if (this.node != null)
		{
			if (this.sailing)
			{
				if (!this.navigator)
				{
					this.SetNodeID(false, false);
				}
				else
				{
					this.SetNodeID(false, this.navigator.moving);
				}
			}
			else
			{
				this.SetNodeID(false, false);
			}
			this.lastNode = this.node;
			return;
		}
		this.lastNode = null;
	}

	// Token: 0x0600024F RID: 591 RVA: 0x00030808 File Offset: 0x0002EA08
	public GraphNode NearNode(Vector3 pos, bool checkEmpty, int uniqueID, int graphIndex)
	{
		this.CheckForNodeID();
		if (Links.x.gaia.noAstar)
		{
			return null;
		}
		this.nodeConstraint.constrainWalkability = true;
		this.nodeConstraint.walkable = true;
		this.nodeConstraint.constrainTags = checkEmpty;
		this.nodeConstraint.checkCircleID = 0;
		this.nodeConstraint.passID = this.nodeStationaryID;
		this.nodeConstraint.passID2 = this.nodeMovingID;
		this.nodeConstraint.constrainPenalty = 0;
		this.nodeConstraint.checkConnections = this.ConnectionNumber();
		this.nodeConstraint.constrainToEnvironment = 2;
		this.nodeConstraint.constrainToArea = -1;
		return Links.x.gaia.exteriorGraph.GetNearestForce(pos, this.nodeConstraint).node;
	}

	// Token: 0x06000250 RID: 592 RVA: 0x000308D5 File Offset: 0x0002EAD5
	public void CheckForNodeID()
	{
		if (this.nodeMovingID == 0)
		{
			this.nodeStationaryID = Records.x.currentPathNode;
			this.nodeMovingID = this.nodeStationaryID + 100;
		}
	}

	// Token: 0x06000251 RID: 593 RVA: 0x00030900 File Offset: 0x0002EB00
	public void SetNodeID(bool overrideDefaults, bool moving)
	{
		this.CheckForNodeID();
		int num = this.nodeMovingID;
		if (!moving)
		{
			num = this.nodeStationaryID;
		}
		if (overrideDefaults)
		{
			if (moving)
			{
				num = this.nodeMovingID;
			}
			else
			{
				num = this.nodeStationaryID;
			}
		}
		if (this.node != null)
		{
			if (num == this.nodeStationaryID)
			{
				this.node.SetFlowerConnections(num, this.nodeMovingID, this.connections);
				return;
			}
			this.node.SetFlowerConnections(num, this.nodeStationaryID, this.connections);
		}
	}

	// Token: 0x06000252 RID: 594 RVA: 0x0003097C File Offset: 0x0002EB7C
	public void SetNodeConstraint(Character pathfinder, bool constrainTags)
	{
		this.nodeConstraint.constrainWalkability = true;
		this.nodeConstraint.walkable = true;
		this.nodeConstraint.constrainPenalty = 0;
		this.nodeConstraint.constrainTags = constrainTags;
		if (!pathfinder)
		{
			this.nodeConstraint.passID = 0;
			this.nodeConstraint.passID2 = 0;
			this.nodeConstraint.checkConnections = 0;
			this.nodeConstraint.constrainPenalty = 0;
		}
		else
		{
			this.nodeConstraint.passID = pathfinder.nodeStationaryID;
			this.nodeConstraint.passID2 = pathfinder.nodeMovingID;
			this.nodeConstraint.checkConnections = pathfinder.ConnectionNumber();
			this.nodeConstraint.constrainPenalty = 2;
		}
		this.nodeConstraint.constrainToArea = -1;
	}

	// Token: 0x06000253 RID: 595 RVA: 0x00030A3E File Offset: 0x0002EC3E
	public int ConnectionNumber()
	{
		return this.connections;
	}

	// Token: 0x06000254 RID: 596 RVA: 0x00030A48 File Offset: 0x0002EC48
	public Vector3 SubtractVectors(Vector3 a, Vector3 b)
	{
		Vector3 vector;
		vector.x = a.x - b.x;
		vector.y = a.y - b.y;
		vector.z = a.z - b.z;
		return vector;
	}

	// Token: 0x06000255 RID: 597 RVA: 0x00030A94 File Offset: 0x0002EC94
	public float AngleDir(Vector3 fwd, Vector3 targetDir, Vector3 up)
	{
		float num = Vector3.Dot(Vector3.Cross(fwd, targetDir), up);
		if (num > 0f)
		{
			return 1f;
		}
		if (num <= 0f)
		{
			return -1f;
		}
		return 1f;
	}

	// Token: 0x040003E5 RID: 997
	[Header("Set up")]
	public Transform[] standingSpots = new Transform[0];

	// Token: 0x040003E6 RID: 998
	public string[] states = new string[0];

	// Token: 0x040003E7 RID: 999
	public float[] stateTimes = new float[0];

	// Token: 0x040003E8 RID: 1000
	public Renderer[] renderers = new Renderer[0];

	// Token: 0x040003E9 RID: 1001
	public bool[] rowLeft = new bool[0];

	// Token: 0x040003EA RID: 1002
	public string animationOpenName = "Boat_open";

	// Token: 0x040003EB RID: 1003
	public int connections = 8;

	// Token: 0x040003EC RID: 1004
	public float speed = 1000f;

	// Token: 0x040003ED RID: 1005
	public float turnSpeed = 6f;

	// Token: 0x040003EE RID: 1006
	public bool partyBoat;

	// Token: 0x040003EF RID: 1007
	public bool useBuoyancy;

	// Token: 0x040003F0 RID: 1008
	public float waveMultiplier;

	// Token: 0x040003F1 RID: 1009
	[Header("Time of Day")]
	public GameObject[] nightObjects = new GameObject[0];

	// Token: 0x040003F2 RID: 1010
	public GameObject[] dayObjects = new GameObject[0];

	// Token: 0x040003F3 RID: 1011
	[Header("Sailing")]
	public bool sailing;

	// Token: 0x040003F4 RID: 1012
	public Character navigator;

	// Token: 0x040003F5 RID: 1013
	public CreatureActions leadCreature;

	// Token: 0x040003F6 RID: 1014
	public List<Character> sailors = new List<Character>();

	// Token: 0x040003F7 RID: 1015
	public Rigidbody rbody;

	// Token: 0x040003F8 RID: 1016
	public RamBuoyancy bouyancy;

	// Token: 0x040003F9 RID: 1017
	public GraphNode node;

	// Token: 0x040003FA RID: 1018
	public GraphNode lastNode;

	// Token: 0x040003FB RID: 1019
	public int nodeMovingID;

	// Token: 0x040003FC RID: 1020
	public int nodeStationaryID;

	// Token: 0x040003FD RID: 1021
	private float updateTime;

	// Token: 0x040003FE RID: 1022
	private float moveDistance;

	// Token: 0x040003FF RID: 1023
	public Vector3 movePoint;

	// Token: 0x04000400 RID: 1024
	public bool closeToPoint;

	// Token: 0x04000401 RID: 1025
	private Quaternion look;

	// Token: 0x04000402 RID: 1026
	private Quaternion savedRot;

	// Token: 0x04000403 RID: 1027
	private Quaternion rot;

	// Token: 0x04000404 RID: 1028
	private Quaternion smoothRot;

	// Token: 0x04000405 RID: 1029
	private Quaternion intervalRot;

	// Token: 0x04000406 RID: 1030
	private Quaternion startRot;

	// Token: 0x04000407 RID: 1031
	private float prevDist;

	// Token: 0x04000408 RID: 1032
	private float intervalY;

	// Token: 0x04000409 RID: 1033
	private float startRotY;

	// Token: 0x0400040A RID: 1034
	private float rotationTime;

	// Token: 0x0400040B RID: 1035
	private float noiseUpdateTime;

	// Token: 0x0400040C RID: 1036
	private float angleRemaining;

	// Token: 0x0400040D RID: 1037
	private float intervalAngleRemaining;

	// Token: 0x0400040E RID: 1038
	public bool turning;

	// Token: 0x0400040F RID: 1039
	public bool rotating;

	// Token: 0x04000410 RID: 1040
	private GraphNode savedTargetNode;

	// Token: 0x04000411 RID: 1041
	public Transform boatFollow;

	// Token: 0x04000412 RID: 1042
	public GameObject boat;

	// Token: 0x04000413 RID: 1043
	public bool setup;

	// Token: 0x04000414 RID: 1044
	public Transform tr;

	// Token: 0x04000415 RID: 1045
	public Transform moveFollow;

	// Token: 0x04000416 RID: 1046
	private Material[] mats;

	// Token: 0x04000417 RID: 1047
	public string model;

	// Token: 0x04000418 RID: 1048
	private int updateTimeCount;

	// Token: 0x04000419 RID: 1049
	public bool canExit;

	// Token: 0x0400041A RID: 1050
	public bool leavingBoat;

	// Token: 0x0400041B RID: 1051
	private Vector3 originalScale;

	// Token: 0x0400041C RID: 1052
	private bool moving;

	// Token: 0x0400041D RID: 1053
	private bool mainTurning;

	// Token: 0x0400041E RID: 1054
	private bool physicsMove;

	// Token: 0x0400041F RID: 1055
	private Vector3 savedAngularVelocity;

	// Token: 0x04000420 RID: 1056
	private Vector3 savedVelocity;

	// Token: 0x04000421 RID: 1057
	private bool pocket;

	// Token: 0x04000422 RID: 1058
	private bool previouslyMoving;

	// Token: 0x04000423 RID: 1059
	private float previouslyMovingStartTime;

	// Token: 0x04000424 RID: 1060
	private float timeSincePath;

	// Token: 0x04000425 RID: 1061
	private Quaternion targetRotation;

	// Token: 0x04000426 RID: 1062
	private Quaternion startCapsizedRot;

	// Token: 0x04000427 RID: 1063
	private bool isCapsized;

	// Token: 0x04000428 RID: 1064
	private bool turningLeft;

	// Token: 0x04000429 RID: 1065
	private bool settingPosition;

	// Token: 0x0400042A RID: 1066
	public GameObject splashBack;

	// Token: 0x0400042B RID: 1067
	public GameObject splashFront;

	// Token: 0x0400042C RID: 1068
	private List<ParticleSystem> splashParticles = new List<ParticleSystem>();

	// Token: 0x0400042D RID: 1069
	public List<GameObject> oarSplashes = new List<GameObject>();

	// Token: 0x0400042E RID: 1070
	[Header("Animation")]
	public Animator animator;

	// Token: 0x0400042F RID: 1071
	public Vector3 boatOpenJumpPosition;

	// Token: 0x04000430 RID: 1072
	public bool inMenu;

	// Token: 0x04000431 RID: 1073
	private float waveValue;

	// Token: 0x04000432 RID: 1074
	private float t1;

	// Token: 0x04000433 RID: 1075
	private float startValue1;

	// Token: 0x04000434 RID: 1076
	private float targetValue1;

	// Token: 0x04000435 RID: 1077
	[Header("Boro")]
	public Transform sheepSpot;

	// Token: 0x04000436 RID: 1078
	private float t;

	// Token: 0x04000437 RID: 1079
	private float startDither;

	// Token: 0x04000438 RID: 1080
	private float endDither;

	// Token: 0x04000439 RID: 1081
	private float removeSummonsTime;

	// Token: 0x0400043A RID: 1082
	private IEnumerator startSailCoroutine;

	// Token: 0x0400043B RID: 1083
	private List<Character> party;

	// Token: 0x0400043C RID: 1084
	private List<Character> allParty;

	// Token: 0x0400043D RID: 1085
	private NNConstraint nodeConstraint = new NNConstraint();

	// Token: 0x0400043E RID: 1086
	private List<GraphNode> allNodes;

	// Token: 0x0400043F RID: 1087
	private List<GraphNode> suitableNodes = new List<GraphNode>();

	// Token: 0x04000440 RID: 1088
	private List<GraphNode> moveNodes = new List<GraphNode>();

	// Token: 0x04000441 RID: 1089
	private List<GraphNode> bestNodes = new List<GraphNode>();

	// Token: 0x04000442 RID: 1090
	private List<GraphNode> partyNodes = new List<GraphNode>();

	// Token: 0x04000443 RID: 1091
	private List<GraphNode> partyBoatNodes = new List<GraphNode>();
}
