public void Constructor2ShouldStoreAndPrintValueAndSymbolWithCubicCentimeters()
{
VolumeOfVoids vv = new VolumeOfVoids(20, VolumeUnits.CubicCentimeters);
GasVolume gv = new GasVolume(10, VolumeUnits.CubicCentimeters);
WaterVolume wv = new WaterVolume(vv, gv, VolumeUnits.CubicCentimeters);
String correctAnswer = "V_w = 10 cc";
Assert.AreEqual("V_w", wv.Symbol);
Assert.AreEqual(wv.NumericValue, 10);
Assert.AreEqual(wv.UnitOfMeasure, VolumeUnits.CubicCentimeters);
Assert.AreEqual(correctAnswer, wv.ToString());
}
public void Constructor2ShouldStoreAndPrintValueAndSymbolWithFt3()
{
VolumeOfVoids vv = new VolumeOfVoids(20, VolumeUnits.CubicCentimeters);
GasVolume gv = new GasVolume(10, VolumeUnits.CubicCentimeters);
WaterVolume wv = new WaterVolume(vv, gv, VolumeUnits.CubicFeet);
String correctAnswer = "V_w = 0 ft^3";
Assert.AreEqual("V_w", wv.Symbol);
Assert.AreEqual(Math.Round(wv.NumericValue, 6), 0.000353);
Assert.AreEqual(wv.UnitOfMeasure, VolumeUnits.CubicFeet);
Assert.AreEqual(correctAnswer, wv.ToString());
}
protected virtual void OnEnable()
{
this.waterVolumeTarget = (WaterVolume)this.target;
this.density = this.serializedObject.FindProperty("density");
this.rows = this.serializedObject.FindProperty("rows");
this.columns = this.serializedObject.FindProperty("columns");
this.quadSegmentSize = this.serializedObject.FindProperty("quadSegmentSize");
//this.debugTrans = this.serializedObject.FindProperty("debugTrans");
Undo.undoRedoPerformed += this.OnUndoRedoPerformed;
}
protected virtual void OnEnable()
{
this.waterVolumeTarget = (WaterVolume)this.target;
this.density = this.serializedObject.FindProperty("density");
this.rows = this.serializedObject.FindProperty("rows");
this.columns = this.serializedObject.FindProperty("columns");
this.quadSegmentSize = this.serializedObject.FindProperty("quadSegmentSize");
//this.debugTrans = this.serializedObject.FindProperty("debugTrans");
Undo.undoRedoPerformed += this.OnUndoRedoPerformed;
}
public void Constructor3ShouldStoreAndPrintValueAndSymbolWithFt3()
{
VolumeOfVoids vv = new VolumeOfVoids(10, VolumeUnits.CubicCentimeters);
DegreeOfSaturation ds = new DegreeOfSaturation(.1);
WaterVolume wv = new WaterVolume(ds, vv, VolumeUnits.CubicFeet);
String correctAnswer = "V_w = 0 ft^3";
Assert.AreEqual("V_w", wv.Symbol);
Assert.AreEqual(Math.Round(wv.NumericValue, 7), 0.0000353);
Assert.AreEqual(wv.UnitOfMeasure, VolumeUnits.CubicFeet);
Assert.AreEqual(correctAnswer, wv.ToString());
}
// 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;
}
}
}
static bool Prefix(WaterVolume __instance, ref float __result, Vector3 point, float waveFactor)
{
return(true);
float wrappedDayTimeSeconds = Time.time * (60 * 60 * 24 / 1200f);
float depth = Traverse.Create(__instance).Method("Depth", new object[] { point }).GetValue <float>();
float num = Traverse.Create(__instance).Method("CalcWave", new object[] { point, depth, wrappedDayTimeSeconds, waveFactor }).GetValue <float>();
float num2 = __instance.transform.position.y + num;
if (Utils.LengthXZ(point) > 10500f && __instance.m_forceDepth < 0f)
{
num2 -= 100f;
}
__result = num2;
return(false);
}
// 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);
protected virtual void OnEnable()
{
this.waterVolumeTarget = (WaterVolume)this.target;
this.rows = this.serializedObject.FindProperty("rows");
this.columns = this.serializedObject.FindProperty("columns");
this.quadSegmentSize = this.serializedObject.FindProperty("quadSegmentSize");
Undo.undoRedoPerformed += this.OnUndoRedoPerformed;
waterVolumeTarget.GetComponent <MeshFilter>().hideFlags = HideFlags.NotEditable;
waterVolumeTarget.GetComponent <BoxCollider>().hideFlags = HideFlags.NotEditable;
waterVolumeTarget.GetComponent <BoxCollider>().isTrigger = true;
waterVolumeTarget.GetComponent <BoxCollider>().enabled = waterVolumeTarget.enabled;
if (Application.isPlaying && !PrefabUtility.IsPartOfPrefabAsset(waterVolumeTarget))
{
waterVolumeTarget.GetComponent <Renderer>().material.hideFlags = HideFlags.NotEditable;
}
}
// Token: 0x06000FFF RID: 4095 RVA: 0x00070928 File Offset: 0x0006EB28
public static float GetWaterLevel(Vector3 p, float waveFactor = 1f)
{
if (WaterVolume.m_waterVolumeMask == 0)
{
WaterVolume.m_waterVolumeMask = LayerMask.GetMask(new string[]
{
"WaterVolume"
});
}
int num = Physics.OverlapSphereNonAlloc(p, 0f, WaterVolume.tempColliderArray, WaterVolume.m_waterVolumeMask);
for (int i = 0; i < num; i++)
{
WaterVolume component = WaterVolume.tempColliderArray[i].GetComponent <WaterVolume>();
if (component)
{
return(component.GetWaterSurface(p, waveFactor));
}
}
return(-10000f);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnitWeightOfWater"/> class.
/// </summary>
/// <param name="waterWeight">W_w in gamma_w=W_w/V_w.</param>
/// <param name="waterVolume">V_w in gamma_w=W_w/V_w.</param>
/// <param name="units">Measurement system to hold value in after calculation.</param>
public UnitWeightOfWater(WeightOfWater waterWeight, WaterVolume waterVolume, UnitWeightUnits units)
: this(ConvertToUnits(new BaseUnitWeightScalar("𝛾", BaseWeightScalar.ConvertToUnits(waterWeight, WeightUnits.Kilograms).NumericValue / BaseVolumeScalar.ConvertToUnits(waterVolume, VolumeUnits.CubicMeters).NumericValue, UnitWeightUnits.KilogramPerMeterCubed), units).NumericValue, units)
{
}
// 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);
}
// 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;
/// <summary>
/// Initializes a new instance of the <see cref="GasVolume"/> class.
/// </summary>
/// <param name="voidVolume">V_v in V_v=V_g+V_w.</param>
/// <param name="waterVolume">V_w in V_v=V_g+V_w.</param>
/// <param name="units">Measurement unit to hold value after initial calculation (ie cc).</param>
public GasVolume(VolumeOfVoids voidVolume, WaterVolume waterVolume, VolumeUnits units)
: this(ConvertToUnits(voidVolume, units).NumericValue - ConvertToUnits(waterVolume, units).NumericValue, units)
{
}
protected virtual void OnTriggerExit(Collider other)
{
if (other.CompareTag(WaterVolume.TAG))
{
this.water = null;
}
}
protected virtual void OnTriggerEnter(Collider other)
{
if (other.CompareTag(WaterVolume.TAG))
{
this.water = other.GetComponent<WaterVolume>();
if (this.voxels == null)
{
this.voxels = this.CutIntoVoxels();
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="VolumeOfVoids"/> class.
/// </summary>
/// <param name="degreeOfSaturation">S in S=V_w/V_v.</param>
/// <param name="waterVolume">V_w in S=V_w/V_v.</param>
/// <param name="units">Measurement units to hold value after initial calculation (ie cc).</param>
public VolumeOfVoids(DegreeOfSaturation degreeOfSaturation, WaterVolume waterVolume, VolumeUnits units)
: this(BaseVolumeScalar.ConvertToUnits(waterVolume, units).NumericValue / degreeOfSaturation.NumericValue, units)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="VolumeOfVoids"/> class.
/// </summary>
/// <param name="waterVolume">V_w in V_v=V_w+V_g.</param>
/// <param name="gasVolume">V_g in V_v=V_w+V_g.</param>
/// <param name="units">Measurement units to hold value after initial calculation (ie cc).</param>
public VolumeOfVoids(WaterVolume waterVolume, GasVolume gasVolume, VolumeUnits units)
: this(ConvertToUnits(waterVolume, units).NumericValue + ConvertToUnits(gasVolume, units).NumericValue, units)
{
}