public Vector3 FindSafePlace()
{
Vector3 vector = 0.5f * (m_componentCreature.ComponentBody.BoundingBox.Min + m_componentCreature.ComponentBody.BoundingBox.Max);
Vector3?herdPosition = (m_componentHerdBehavior != null) ? m_componentHerdBehavior.FindHerdCenter() : null;
float num = float.NegativeInfinity;
Vector3 result = vector;
for (int i = 0; i < 40; i++)
{
Vector2 vector2 = m_random.Vector2(1f, 1f);
float y = 0.4f * m_random.Float(-1f, 1f);
Vector3 v = Vector3.Normalize(new Vector3(vector2.X, y, vector2.Y));
Vector3 vector3 = vector + m_random.Float(10f, 20f) * v;
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(vector, vector3, useInteractionBoxes : false, skipAirBlocks : false, delegate(int value, float d)
{
int num3 = Terrain.ExtractContents(value);
return(!(BlocksManager.Blocks[num3] is WaterBlock));
});
Vector3 vector4 = terrainRaycastResult.HasValue ? (vector + v * terrainRaycastResult.Value.Distance) : vector3;
float num2 = ScoreSafePlace(vector, vector4, herdPosition);
if (num2 > num)
{
num = num2;
result = vector4;
}
}
return(result);
}
public Vector3?FindDestination()
{
Vector3 vector = 0.5f * (m_componentCreature.ComponentBody.BoundingBox.Min + m_componentCreature.ComponentBody.BoundingBox.Max);
float num = 2f;
Vector3?result = null;
float num2 = m_random.Float(10f, 16f);
for (int i = 0; i < 16; i++)
{
Vector2 vector2 = m_random.Vector2(1f, 1f);
float y = 0.3f * m_random.Float(-0.9f, 1f);
Vector3 v = Vector3.Normalize(new Vector3(vector2.X, y, vector2.Y));
Vector3 vector3 = vector + num2 * v;
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(vector, vector3, useInteractionBoxes : false, skipAirBlocks : false, delegate(int value, float d)
{
int num3 = Terrain.ExtractContents(value);
return(!(BlocksManager.Blocks[num3] is WaterBlock));
});
if (!terrainRaycastResult.HasValue)
{
if (num2 > num)
{
result = vector3;
num = num2;
}
}
else if (terrainRaycastResult.Value.Distance > num)
{
result = vector + v * terrainRaycastResult.Value.Distance;
num = terrainRaycastResult.Value.Distance;
}
}
return(result);
}
public object Raycast(Ray3 ray, RaycastMode mode, bool raycastTerrain = true, bool raycastBodies = true, bool raycastMovingBlocks = true)
{
float reach = (m_subsystemGameInfo.WorldSettings.GameMode == GameMode.Creative) ? SettingsManager.CreativeReach : 5f;
Vector3 creaturePosition = ComponentCreature.ComponentCreatureModel.EyePosition;
Vector3 start = ray.Position;
Vector3 direction = Vector3.Normalize(ray.Direction);
Vector3 end = ray.Position + direction * 15f;
Point3 startCell = Terrain.ToCell(start);
BodyRaycastResult? bodyRaycastResult = m_subsystemBodies.Raycast(start, end, 0.35f, (ComponentBody body, float distance) => (Vector3.DistanceSquared(start + distance * direction, creaturePosition) <= reach * reach && body.Entity != base.Entity && !body.IsChildOfBody(ComponentCreature.ComponentBody) && !ComponentCreature.ComponentBody.IsChildOfBody(body) && Vector3.Dot(Vector3.Normalize(body.BoundingBox.Center() - start), direction) > 0.7f) ? true : false);
MovingBlocksRaycastResult?movingBlocksRaycastResult = m_subsystemMovingBlocks.Raycast(start, end, extendToFillCells: true);
TerrainRaycastResult? terrainRaycastResult = m_subsystemTerrain.Raycast(start, end, useInteractionBoxes : true, skipAirBlocks : true, delegate(int value, float distance)
{
if (Vector3.DistanceSquared(start + distance * direction, creaturePosition) <= reach * reach)
{
Block block = BlocksManager.Blocks[Terrain.ExtractContents(value)];
if (distance == 0f && block is CrossBlock && Vector3.Dot(direction, new Vector3(startCell) + new Vector3(0.5f) - start) < 0f)
{
return(false);
}
if (mode == RaycastMode.Digging)
{
return(!block.IsDiggingTransparent);
}
if (mode == RaycastMode.Interaction)
{
if (block.IsPlacementTransparent)
{
return(block.IsInteractive(m_subsystemTerrain, value));
}
return(true);
}
if (mode == RaycastMode.Gathering)
{
return(block.IsGatherable);
}
}
return(false);
});
float num = bodyRaycastResult.HasValue ? bodyRaycastResult.Value.Distance : float.PositiveInfinity;
float num2 = movingBlocksRaycastResult.HasValue ? movingBlocksRaycastResult.Value.Distance : float.PositiveInfinity;
float num3 = terrainRaycastResult.HasValue ? terrainRaycastResult.Value.Distance : float.PositiveInfinity;
if (num < num2 && num < num3)
{
return(bodyRaycastResult.Value);
}
if (num2 < num && num2 < num3)
{
return(movingBlocksRaycastResult.Value);
}
if (num3 < num && num3 < num2)
{
return(terrainRaycastResult.Value);
}
return(new Ray3(start, direction));
}
public void ExplodeFireworks(Vector3 position, int data)
{
for (int i = 0; i < 3; i++)
{
Vector3 v = new Vector3(m_random.Float(-3f, 3f), -15f, m_random.Float(-3f, 3f));
if (m_subsystemTerrain.Raycast(position, position + v, useInteractionBoxes: false, skipAirBlocks: true, null).HasValue)
{
return;
}
}
FireworksBlock.Shape shape = FireworksBlock.GetShape(data);
float flickering = FireworksBlock.GetFlickering(data) ? 0.66f : 0f;
float particleSize = (FireworksBlock.GetAltitude(data) > 0) ? 1.1f : 1f;
Color color = FireworksBlock.FireworksColors[FireworksBlock.GetColor(data)];
m_subsystemParticles.AddParticleSystem(new FireworksParticleSystem(position, color, shape, flickering, particleSize));
m_subsystemAudio.PlayRandomSound("Audio/FireworksPop", 1f, m_random.Float(-0.4f, 0f), position, 80f, autoDelay: true);
m_subsystemNoise.MakeNoise(position, 1f, 60f);
}
public void StartDismounting()
{
if (!m_isAnimating && Mount != null)
{
float x = 0f;
if (Mount.DismountOffset.X > 0f)
{
float s = Mount.DismountOffset.X + 0.5f;
Vector3 vector = 0.5f * (ComponentCreature.ComponentBody.BoundingBox.Min + ComponentCreature.ComponentBody.BoundingBox.Max);
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(vector, vector - s * ComponentCreature.ComponentBody.Matrix.Right, useInteractionBoxes: false, skipAirBlocks: true, null);
TerrainRaycastResult?terrainRaycastResult2 = m_subsystemTerrain.Raycast(vector, vector + s * ComponentCreature.ComponentBody.Matrix.Right, useInteractionBoxes: false, skipAirBlocks: true, null);
x = ((!terrainRaycastResult.HasValue) ? (0f - Mount.DismountOffset.X) : ((!terrainRaycastResult2.HasValue) ? Mount.DismountOffset.X : ((!(terrainRaycastResult.Value.Distance > terrainRaycastResult2.Value.Distance)) ? MathUtils.Min(terrainRaycastResult2.Value.Distance, Mount.DismountOffset.X) : (0f - MathUtils.Min(terrainRaycastResult.Value.Distance, Mount.DismountOffset.X)))));
}
m_isAnimating = true;
m_animationTime = 0f;
m_isDismounting = true;
m_targetPositionOffset = Mount.MountOffset + m_riderOffset + new Vector3(x, Mount.DismountOffset.Y, Mount.DismountOffset.Z);
m_targetRotationOffset = Quaternion.CreateFromAxisAngle(Vector3.UnitY, MathUtils.Sign(x) * MathUtils.DegToRad(60f));
}
}
public bool IsPassable(Vector3 p1, Vector3 p2, Vector3 boxSize)
{
Vector3 vector = new Vector3(p1.X, p1.Y + 0.5f, p1.Z);
Vector3 vector2 = new Vector3(p2.X, p2.Y + 0.5f, p2.Z);
Vector3 v = (0.5f * boxSize.X + 0.1f) * Vector3.Normalize(Vector3.Cross(Vector3.UnitY, vector2 - vector));
if (m_subsystemTerrain.Raycast(vector, vector2, useInteractionBoxes: false, skipAirBlocks: true, SmoothingRaycastFunction_Obstacle).HasValue)
{
return(false);
}
if (m_subsystemTerrain.Raycast(vector - v, vector2 - v, useInteractionBoxes: false, skipAirBlocks: true, SmoothingRaycastFunction_Obstacle).HasValue)
{
return(false);
}
if (m_subsystemTerrain.Raycast(vector + v, vector2 + v, useInteractionBoxes: false, skipAirBlocks: true, SmoothingRaycastFunction_Obstacle).HasValue)
{
return(false);
}
if (m_subsystemTerrain.Raycast(vector + new Vector3(0f, -1f, 0f), vector2 + new Vector3(0f, -1f, 0f), useInteractionBoxes: false, skipAirBlocks: false, SmoothingRaycastFunction_Support).HasValue)
{
return(false);
}
if (m_subsystemTerrain.Raycast(vector + new Vector3(0f, -1f, 0f) - v, vector2 + new Vector3(0f, -1f, 0f) - v, useInteractionBoxes: false, skipAirBlocks: false, SmoothingRaycastFunction_Support).HasValue)
{
return(false);
}
if (m_subsystemTerrain.Raycast(vector + new Vector3(0f, -1f, 0f) + v, vector2 + new Vector3(0f, -1f, 0f) + v, useInteractionBoxes: false, skipAirBlocks: false, SmoothingRaycastFunction_Support).HasValue)
{
return(false);
}
return(true);
}
public override bool Simulate(float dt)
{
dt = MathUtils.Clamp(dt, 0f, 0.1f);
float num = MathUtils.Pow(0.04f, dt);
bool flag = false;
for (int i = 0; i < base.Particles.Length; i++)
{
Particle particle = base.Particles[i];
if (!particle.IsActive)
{
continue;
}
flag = true;
particle.TimeToLive -= dt;
if (particle.TimeToLive > 0f)
{
Vector3 position = particle.Position;
Vector3 vector = position + particle.Velocity * dt;
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(position, vector, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => BlocksManager.Blocks[Terrain.ExtractContents(value)].IsCollidable);
if (terrainRaycastResult.HasValue)
{
Plane plane = terrainRaycastResult.Value.CellFace.CalculatePlane();
vector = position;
if (plane.Normal.X != 0f)
{
particle.Velocity *= new Vector3(-0.1f, 0.1f, 0.1f);
}
if (plane.Normal.Y != 0f)
{
particle.Velocity *= new Vector3(0.1f, -0.1f, 0.1f);
}
if (plane.Normal.Z != 0f)
{
particle.Velocity *= new Vector3(0.1f, 0.1f, -0.1f);
}
}
particle.Position = vector;
particle.Velocity.Y += -10f * dt;
particle.Velocity *= num;
particle.Color *= MathUtils.Saturate(particle.TimeToLive);
particle.TextureSlot = (int)(8.99f * MathUtils.Saturate(2f - particle.TimeToLive));
}
else
{
particle.IsActive = false;
}
}
return(!flag);
}
public Projectile FireProjectile(int value, Vector3 position, Vector3 velocity, Vector3 angularVelocity, ComponentCreature owner)
{
int num = Terrain.ExtractContents(value);
Block block = BlocksManager.Blocks[num];
Vector3 v = Vector3.Normalize(velocity);
Vector3 vector = position;
if (owner != null)
{
Ray3 ray = new Ray3(position + v * 5f, -v);
BoundingBox boundingBox = owner.ComponentBody.BoundingBox;
boundingBox.Min -= new Vector3(0.4f);
boundingBox.Max += new Vector3(0.4f);
float?num2 = ray.Intersection(boundingBox);
if (num2.HasValue)
{
if (num2.Value == 0f)
{
return(null);
}
vector = position + v * (5f - num2.Value + 0.1f);
}
}
Vector3 end = vector + v * block.ProjectileTipOffset;
if (!m_subsystemTerrain.Raycast(position, end, useInteractionBoxes: false, skipAirBlocks: true, (int testValue, float distance) => BlocksManager.Blocks[Terrain.ExtractContents(testValue)].IsCollidable).HasValue)
{
Projectile projectile = AddProjectile(value, vector, velocity, angularVelocity, owner);
SubsystemBlockBehavior[] blockBehaviors = m_subsystemBlockBehaviors.GetBlockBehaviors(num);
for (int i = 0; i < blockBehaviors.Length; i++)
{
blockBehaviors[i].OnFiredAsProjectile(projectile);
}
return(projectile);
}
return(null);
}
public override bool Simulate(float dt)
{
dt = MathUtils.Clamp(dt, 0f, 0.1f);
float num = MathUtils.Pow(0.2f, dt);
float num2 = MathUtils.Pow(1E-07f, dt);
bool flag = false;
for (int i = 0; i < base.Particles.Length; i++)
{
Particle particle = base.Particles[i];
if (!particle.IsActive)
{
continue;
}
flag = true;
particle.TimeToLive -= dt;
if (particle.TimeToLive > 0f)
{
Vector3 position = particle.Position;
Vector3 vector = position + particle.Velocity * dt;
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(position, vector, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => BlocksManager.Blocks[Terrain.ExtractContents(value)].IsCollidable);
if (terrainRaycastResult.HasValue)
{
particle.Velocity = Vector3.Zero;
particle.Position = terrainRaycastResult.Value.HitPoint(0.03f);
particle.HighDampingFactor = m_random.Float(0.5f, 1f);
if (terrainRaycastResult.Value.CellFace.Face >= 4)
{
particle.NoGravity = true;
}
}
else
{
particle.Position = vector;
}
if (!particle.NoGravity)
{
particle.Velocity.Y += -9.81f * dt;
}
particle.Velocity *= ((particle.HighDampingFactor > 0f) ? (num2 * particle.HighDampingFactor) : num);
particle.Color = m_color * MathUtils.Saturate(1.5f * particle.TimeToLive * particle.Alpha);
}
else
{
particle.IsActive = false;
}
}
return(!flag);
}
public float ScoreIntroSpawnPosition(Vector2 desiredSpawnPosition, int x, int z)
{
float num = -0.01f * Vector2.Distance(new Vector2(x, z), desiredSpawnPosition);
int num2 = m_subsystemTerrain.Terrain.CalculateTopmostCellHeight(x, z);
if (num2 < 64 || num2 > 85)
{
num -= 5f;
}
if (m_subsystemTerrain.Terrain.GetSeasonalTemperature(x, z) < 8)
{
num -= 5f;
}
int cellContents = m_subsystemTerrain.Terrain.GetCellContents(x, num2, z);
if (BlocksManager.Blocks[cellContents].IsTransparent)
{
num -= 5f;
}
for (int i = x - 1; i <= x + 1; i++)
{
for (int j = z - 1; j <= z + 1; j++)
{
if (m_subsystemTerrain.Terrain.GetCellContents(i, num2 + 2, j) != 0)
{
num -= 1f;
}
}
}
Vector2 vector = ComponentIntro.FindOceanDirection(m_subsystemTerrain.TerrainContentsGenerator, new Vector2(x, z));
Vector3 vector2 = new Vector3(x, (float)num2 + 1.5f, z);
for (int k = -1; k <= 1; k++)
{
Vector3 end = vector2 + new Vector3(30f * vector.X, 5f * (float)k, 30f * vector.Y);
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(vector2, end, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => Terrain.ExtractContents(value) != 0);
if (terrainRaycastResult.HasValue)
{
CellFace cellFace = terrainRaycastResult.Value.CellFace;
int cellContents2 = m_subsystemTerrain.Terrain.GetCellContents(cellFace.X, cellFace.Y, cellFace.Z);
if (cellContents2 != 18 && cellContents2 != 0)
{
num -= 2f;
}
}
}
return(num);
}
public Vector3?FindSurfaceDestination()
{
Vector3 vector = 0.5f * (m_componentCreature.ComponentBody.BoundingBox.Min + m_componentCreature.ComponentBody.BoundingBox.Max);
Vector3 forward = m_componentCreature.ComponentBody.Matrix.Forward;
float s = 2f * m_componentCreature.ComponentBody.ImmersionDepth;
for (int i = 0; i < 16; i++)
{
Vector2 vector2 = (i < 4) ? (new Vector2(forward.X, forward.Z) + m_random.Vector2(0f, 0.25f)) : m_random.Vector2(0.5f, 1f);
Vector3 v = Vector3.Normalize(new Vector3(vector2.X, 1f, vector2.Y));
Vector3 end = vector + s * v;
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(vector, end, useInteractionBoxes: false, skipAirBlocks: false, (int value, float d) => Terrain.ExtractContents(value) != 18);
if (terrainRaycastResult.HasValue && Terrain.ExtractContents(terrainRaycastResult.Value.Value) == 0)
{
return(new Vector3((float)terrainRaycastResult.Value.CellFace.X + 0.5f, terrainRaycastResult.Value.CellFace.Y, (float)terrainRaycastResult.Value.CellFace.Z + 0.5f));
}
}
return(null);
}
public bool CanSleep(out string reason)
{
Block block = m_componentPlayer.ComponentBody.StandingOnValue.HasValue ? BlocksManager.Blocks[Terrain.ExtractContents(m_componentPlayer.ComponentBody.StandingOnValue.Value)] : null;
if (block == null || m_componentPlayer.ComponentBody.ImmersionDepth > 0f)
{
reason = LanguageControl.Get(fName, 1);
return(false);
}
if (block != null && block.SleepSuitability == 0f)
{
reason = LanguageControl.Get(fName, 2);
return(false);
}
if (m_componentPlayer.ComponentVitalStats.Sleep > 0.99f)
{
reason = LanguageControl.Get(fName, 3);
return(false);
}
if (m_componentPlayer.ComponentVitalStats.Wetness > 0.95f)
{
reason = LanguageControl.Get(fName, 4);
return(false);
}
for (int i = -1; i <= 1; i++)
{
for (int j = -1; j <= 1; j++)
{
Vector3 start = m_componentPlayer.ComponentBody.Position + new Vector3(i, 1f, j);
Vector3 end = new Vector3(start.X, 255f, start.Z);
if (!m_subsystemTerrain.Raycast(start, end, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => Terrain.ExtractContents(value) != 0).HasValue)
{
reason = LanguageControl.Get(fName, 5);
return(false);
}
}
}
reason = string.Empty;
return(true);
}
public Vector3?FindDestination()
{
for (int i = 0; i < 8; i++)
{
Vector2 vector = m_random.Vector2(1f, 1f);
float y = 0.2f * m_random.Float(-0.8f, 1f);
Vector3 v = Vector3.Normalize(new Vector3(vector.X, y, vector.Y));
Vector3 vector2 = m_componentCreature.ComponentBody.Position + m_random.Float(8f, 16f) * v;
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(m_componentCreature.ComponentBody.Position, vector2, useInteractionBoxes : false, skipAirBlocks : false, delegate(int value, float d)
{
int num = Terrain.ExtractContents(value);
return(!(BlocksManager.Blocks[num] is WaterBlock));
});
if (!terrainRaycastResult.HasValue)
{
return(vector2);
}
if (terrainRaycastResult.Value.Distance > 4f)
{
return(m_componentCreature.ComponentBody.Position + v * terrainRaycastResult.Value.Distance);
}
}
return(null);
}
public override bool Simulate(float dt)
{
int num = Terrain.ToCell(Position.X);
int num2 = Terrain.ToCell(Position.Y);
int num3 = Terrain.ToCell(Position.Z);
int x = 0;
x = MathUtils.Max(x, m_subsystemTerrain.Terrain.GetCellLight(num + 1, num2, num3));
x = MathUtils.Max(x, m_subsystemTerrain.Terrain.GetCellLight(num - 1, num2, num3));
x = MathUtils.Max(x, m_subsystemTerrain.Terrain.GetCellLight(num, num2 + 1, num3));
x = MathUtils.Max(x, m_subsystemTerrain.Terrain.GetCellLight(num, num2 - 1, num3));
x = MathUtils.Max(x, m_subsystemTerrain.Terrain.GetCellLight(num, num2, num3 + 1));
x = MathUtils.Max(x, m_subsystemTerrain.Terrain.GetCellLight(num, num2, num3 - 1));
Color white = Color.White;
float num4 = LightingManager.LightIntensityByLightValue[x];
white *= num4;
white.A = byte.MaxValue;
dt = MathUtils.Clamp(dt, 0f, 0.1f);
float num5 = MathUtils.Pow(0.03f, dt);
m_duration += dt;
if (m_duration > 3.5f)
{
IsStopped = true;
}
float num6 = MathUtils.Saturate(1.3f * SimplexNoise.Noise(3f * m_duration + (float)(GetHashCode() % 100)) - 0.3f);
float num7 = 30f * num6;
m_toGenerate += num7 * dt;
bool flag = false;
for (int i = 0; i < base.Particles.Length; i++)
{
Particle particle = base.Particles[i];
if (particle.IsActive)
{
flag = true;
particle.TimeToLive -= dt;
if (particle.TimeToLive > 0f)
{
Vector3 position = particle.Position;
Vector3 vector = position + particle.Velocity * dt;
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(position, vector, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => BlocksManager.Blocks[Terrain.ExtractContents(value)].IsCollidable);
if (terrainRaycastResult.HasValue)
{
Plane plane = terrainRaycastResult.Value.CellFace.CalculatePlane();
vector = position;
if (plane.Normal.X != 0f)
{
particle.Velocity *= new Vector3(-0.05f, 0.05f, 0.05f);
}
if (plane.Normal.Y != 0f)
{
particle.Velocity *= new Vector3(0.05f, -0.05f, 0.05f);
}
if (plane.Normal.Z != 0f)
{
particle.Velocity *= new Vector3(0.05f, 0.05f, -0.05f);
}
}
particle.Position = vector;
particle.Velocity.Y += -9.81f * dt;
particle.Velocity *= num5;
particle.Color *= MathUtils.Saturate(particle.TimeToLive);
particle.TextureSlot = (int)(8.99f * MathUtils.Saturate(3f - particle.TimeToLive));
}
else
{
particle.IsActive = false;
}
}
else if (!IsStopped && m_toGenerate >= 1f)
{
Vector3 v = m_random.Vector3(0f, 1f);
particle.IsActive = true;
particle.Position = Position + 0.05f * v;
particle.Color = Color.MultiplyColorOnly(white, m_random.Float(0.7f, 1f));
particle.Velocity = MathUtils.Lerp(1f, 2.5f, num6) * Vector3.Normalize(Direction + 0.25f * v);
particle.TimeToLive = 3f;
particle.Size = new Vector2(0.1f);
particle.FlipX = m_random.Bool();
particle.FlipY = m_random.Bool();
m_toGenerate -= 1f;
}
}
if (IsStopped)
{
return(!flag);
}
return(false);
}
public void Update(float dt)
{
if (m_subsystemTime.GameTime >= m_nextUpdateTime)
{
m_nextUpdateTime = m_subsystemTime.GameTime + (double)m_random.Float(0.09f, 0.11f);
m_walkOrder = null;
m_flyOrder = null;
m_swimOrder = null;
m_turnOrder = Vector2.Zero;
m_jumpOrder = 0f;
if (Destination.HasValue)
{
Vector3 position = m_componentCreature.ComponentBody.Position;
Vector3 forward = m_componentCreature.ComponentBody.Matrix.Forward;
Vector3 v = AvoidNearestBody(position, Destination.Value);
Vector3 vector = v - position;
float num = vector.LengthSquared();
Vector2 vector2 = new Vector2(v.X, v.Z) - new Vector2(position.X, position.Z);
float num2 = vector2.LengthSquared();
float x = Vector2.Angle(forward.XZ, vector.XZ);
float num3 = ((m_componentCreature.ComponentBody.CollisionVelocityChange * new Vector3(1f, 0f, 1f)).LengthSquared() > 0f && m_componentCreature.ComponentBody.StandingOnValue.HasValue) ? 0.15f : 0.4f;
if (m_subsystemTime.GameTime >= m_lastStuckCheckTime + (double)num3 || !m_lastStuckCheckPosition.HasValue)
{
m_lastStuckCheckTime = m_subsystemTime.GameTime;
if (MathUtils.Abs(x) > MathUtils.DegToRad(20f) || !m_lastStuckCheckPosition.HasValue || Vector3.Dot(position - m_lastStuckCheckPosition.Value, Vector3.Normalize(vector)) > 0.2f)
{
m_lastStuckCheckPosition = position;
m_stuckCount = 0;
}
else
{
m_stuckCount++;
}
IsStuck = (m_stuckCount >= 4);
}
if (m_componentCreature.ComponentLocomotion.FlySpeed > 0f && (num > 9f || vector.Y > 0.5f || vector.Y < -1.5f || (!m_componentCreature.ComponentBody.StandingOnValue.HasValue && m_componentCreature.ComponentBody.ImmersionFactor == 0f)) && m_componentCreature.ComponentBody.ImmersionFactor < 1f)
{
float y = MathUtils.Min(0.08f * vector2.LengthSquared(), 12f);
Vector3 v2 = v + new Vector3(0f, y, 0f);
Vector3 value2 = Speed * Vector3.Normalize(v2 - position);
value2.Y = MathUtils.Max(value2.Y, -0.5f);
m_flyOrder = value2;
m_turnOrder = new Vector2(MathUtils.Clamp(x, -1f, 1f), 0f);
}
else if (m_componentCreature.ComponentLocomotion.SwimSpeed > 0f && m_componentCreature.ComponentBody.ImmersionFactor > 0.5f)
{
Vector3 value3 = Speed * Vector3.Normalize(v - position);
value3.Y = MathUtils.Clamp(value3.Y, -0.5f, 0.5f);
m_swimOrder = value3;
m_turnOrder = new Vector2(MathUtils.Clamp(x, -1f, 1f), 0f);
}
else if (m_componentCreature.ComponentLocomotion.WalkSpeed > 0f)
{
if (IsTerrainSafeToGo(position, vector))
{
m_turnOrder = new Vector2(MathUtils.Clamp(x, -1f, 1f), 0f);
if (num2 > 1f)
{
m_walkOrder = new Vector2(0f, MathUtils.Lerp(Speed, 0f, MathUtils.Saturate((MathUtils.Abs(x) - 0.33f) / 0.66f)));
if (Speed >= 1f && m_componentCreature.ComponentLocomotion.InAirWalkFactor >= 1f && num > 1f && m_random.Float(0f, 1f) < 0.05f)
{
m_jumpOrder = 1f;
}
}
else
{
float x2 = Speed * MathUtils.Min(1f * MathUtils.Sqrt(num2), 1f);
m_walkOrder = new Vector2(0f, MathUtils.Lerp(x2, 0f, MathUtils.Saturate(2f * MathUtils.Abs(x))));
}
}
else
{
IsStuck = true;
}
if (num2 < 1f && vector.Y < -0.1f)
{
m_componentCreature.ComponentBody.IsSmoothRiseEnabled = false;
}
else
{
m_componentCreature.ComponentBody.IsSmoothRiseEnabled = true;
}
if (num2 < 1f && (vector.Y < -0.5f || vector.Y > 1f))
{
if (vector.Y > 0f && m_random.Float(0f, 1f) < 0.05f)
{
m_jumpOrder = 1f;
}
if (!m_aboveBelowTime.HasValue)
{
m_aboveBelowTime = m_subsystemTime.GameTime;
}
else if (m_subsystemTime.GameTime - m_aboveBelowTime.Value > 2.0 && m_componentCreature.ComponentBody.StandingOnValue.HasValue)
{
IsStuck = true;
}
}
else
{
m_aboveBelowTime = null;
}
}
if ((!IgnoreHeightDifference) ? (num <= Range * Range) : (num2 <= Range * Range))
{
if (RaycastDestination)
{
if (!m_subsystemTerrain.Raycast(position + new Vector3(0f, 0.5f, 0f), v + new Vector3(0f, 0.5f, 0f), useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => BlocksManager.Blocks[Terrain.ExtractContents(value)].IsCollidable).HasValue)
{
Destination = null;
}
}
else
{
Destination = null;
}
}
}
if (!Destination.HasValue && m_componentCreature.ComponentLocomotion.FlySpeed > 0f && !m_componentCreature.ComponentBody.StandingOnValue.HasValue && m_componentCreature.ComponentBody.ImmersionFactor == 0f)
{
m_turnOrder = Vector2.Zero;
m_walkOrder = null;
m_swimOrder = null;
m_flyOrder = new Vector3(0f, -0.5f, 0f);
}
}
m_componentCreature.ComponentLocomotion.WalkOrder = CombineNullables(m_componentCreature.ComponentLocomotion.WalkOrder, m_walkOrder);
m_componentCreature.ComponentLocomotion.SwimOrder = CombineNullables(m_componentCreature.ComponentLocomotion.SwimOrder, m_swimOrder);
m_componentCreature.ComponentLocomotion.TurnOrder += m_turnOrder;
m_componentCreature.ComponentLocomotion.FlyOrder = CombineNullables(m_componentCreature.ComponentLocomotion.FlyOrder, m_flyOrder);
m_componentCreature.ComponentLocomotion.JumpOrder = MathUtils.Max(m_jumpOrder, m_componentCreature.ComponentLocomotion.JumpOrder);
m_jumpOrder = 0f;
}
public void Update(float dt)
{
double totalElapsedGameTime = m_subsystemGameInfo.TotalElapsedGameTime;
float num = MathUtils.Pow(0.5f, dt);
float num2 = MathUtils.Pow(0.001f, dt);
m_tmpPlayers.Clear();
foreach (ComponentPlayer componentPlayer in m_subsystemPlayers.ComponentPlayers)
{
if (componentPlayer.ComponentHealth.Health > 0f)
{
m_tmpPlayers.Add(componentPlayer);
}
}
foreach (Pickable pickable in m_pickables)
{
if (pickable.ToRemove)
{
m_pickablesToRemove.Add(pickable);
}
else
{
Block block = BlocksManager.Blocks[Terrain.ExtractContents(pickable.Value)];
int num3 = m_pickables.Count - m_pickablesToRemove.Count;
float num4 = MathUtils.Lerp(300f, 90f, MathUtils.Saturate((float)num3 / 60f));
double num5 = totalElapsedGameTime - pickable.CreationTime;
if (num5 > (double)num4)
{
pickable.ToRemove = true;
}
else
{
TerrainChunk chunkAtCell = m_subsystemTerrain.Terrain.GetChunkAtCell(Terrain.ToCell(pickable.Position.X), Terrain.ToCell(pickable.Position.Z));
if (chunkAtCell != null && chunkAtCell.State > TerrainChunkState.InvalidContents4)
{
Vector3 position = pickable.Position;
Vector3 vector = position + pickable.Velocity * dt;
if (!pickable.FlyToPosition.HasValue && num5 > 0.5)
{
foreach (ComponentPlayer tmpPlayer in m_tmpPlayers)
{
ComponentBody componentBody = tmpPlayer.ComponentBody;
Vector3 v = componentBody.Position + new Vector3(0f, 0.75f, 0f);
float num6 = (v - pickable.Position).LengthSquared();
if (num6 < 3.0625f)
{
bool flag = Terrain.ExtractContents(pickable.Value) == 248;
IInventory inventory = tmpPlayer.ComponentMiner.Inventory;
if (flag || ComponentInventoryBase.FindAcquireSlotForItem(inventory, pickable.Value) >= 0)
{
if (num6 < 1f)
{
if (flag)
{
tmpPlayer.ComponentLevel.AddExperience(pickable.Count, playSound: true);
pickable.ToRemove = true;
}
else
{
pickable.Count = ComponentInventoryBase.AcquireItems(inventory, pickable.Value, pickable.Count);
if (pickable.Count == 0)
{
pickable.ToRemove = true;
m_subsystemAudio.PlaySound("Audio/PickableCollected", 0.7f, -0.4f, pickable.Position, 2f, autoDelay: false);
}
}
}
else if (!pickable.StuckMatrix.HasValue)
{
pickable.FlyToPosition = v + 0.1f * MathUtils.Sqrt(num6) * componentBody.Velocity;
}
}
}
}
}
if (pickable.FlyToPosition.HasValue)
{
Vector3 v2 = pickable.FlyToPosition.Value - pickable.Position;
float num7 = v2.LengthSquared();
if (num7 >= 0.25f)
{
pickable.Velocity = 6f * v2 / MathUtils.Sqrt(num7);
}
else
{
pickable.FlyToPosition = null;
}
}
else
{
FluidBlock surfaceBlock;
float? surfaceHeight;
Vector2? vector2 = m_subsystemFluidBlockBehavior.CalculateFlowSpeed(Terrain.ToCell(pickable.Position.X), Terrain.ToCell(pickable.Position.Y + 0.1f), Terrain.ToCell(pickable.Position.Z), out surfaceBlock, out surfaceHeight);
if (!pickable.StuckMatrix.HasValue)
{
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(position, vector, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => BlocksManager.Blocks[Terrain.ExtractContents(value)].IsCollidable);
if (terrainRaycastResult.HasValue)
{
int contents = Terrain.ExtractContents(m_subsystemTerrain.Terrain.GetCellValue(terrainRaycastResult.Value.CellFace.X, terrainRaycastResult.Value.CellFace.Y, terrainRaycastResult.Value.CellFace.Z));
SubsystemBlockBehavior[] blockBehaviors = m_subsystemBlockBehaviors.GetBlockBehaviors(contents);
for (int i = 0; i < blockBehaviors.Length; i++)
{
blockBehaviors[i].OnHitByProjectile(terrainRaycastResult.Value.CellFace, pickable);
}
if (m_subsystemTerrain.Raycast(position, position, useInteractionBoxes: false, skipAirBlocks: true, (int value2, float distance) => BlocksManager.Blocks[Terrain.ExtractContents(value2)].IsCollidable).HasValue)
{
int num8 = Terrain.ToCell(position.X);
int num9 = Terrain.ToCell(position.Y);
int num10 = Terrain.ToCell(position.Z);
int num11 = 0;
int num12 = 0;
int num13 = 0;
int?num14 = null;
for (int j = -3; j <= 3; j++)
{
for (int k = -3; k <= 3; k++)
{
for (int l = -3; l <= 3; l++)
{
if (!BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(j + num8, k + num9, l + num10)].IsCollidable)
{
int num15 = j * j + k * k + l * l;
if (!num14.HasValue || num15 < num14.Value)
{
num11 = j + num8;
num12 = k + num9;
num13 = l + num10;
num14 = num15;
}
}
}
}
}
if (num14.HasValue)
{
pickable.FlyToPosition = new Vector3(num11, num12, num13) + new Vector3(0.5f);
}
else
{
pickable.ToRemove = true;
}
}
else
{
Plane plane = terrainRaycastResult.Value.CellFace.CalculatePlane();
bool flag2 = vector2.HasValue && vector2.Value != Vector2.Zero;
if (plane.Normal.X != 0f)
{
float num16 = (flag2 || MathUtils.Sqrt(MathUtils.Sqr(pickable.Velocity.Y) + MathUtils.Sqr(pickable.Velocity.Z)) > 10f) ? 0.95f : 0.25f;
pickable.Velocity *= new Vector3(0f - num16, num16, num16);
}
if (plane.Normal.Y != 0f)
{
float num17 = (flag2 || MathUtils.Sqrt(MathUtils.Sqr(pickable.Velocity.X) + MathUtils.Sqr(pickable.Velocity.Z)) > 10f) ? 0.95f : 0.25f;
pickable.Velocity *= new Vector3(num17, 0f - num17, num17);
if (flag2)
{
pickable.Velocity.Y += 0.1f * plane.Normal.Y;
}
}
if (plane.Normal.Z != 0f)
{
float num18 = (flag2 || MathUtils.Sqrt(MathUtils.Sqr(pickable.Velocity.X) + MathUtils.Sqr(pickable.Velocity.Y)) > 10f) ? 0.95f : 0.25f;
pickable.Velocity *= new Vector3(num18, num18, 0f - num18);
}
vector = position;
}
}
}
else
{
Vector3 vector3 = pickable.StuckMatrix.Value.Translation + pickable.StuckMatrix.Value.Up * block.ProjectileTipOffset;
if (!m_subsystemTerrain.Raycast(vector3, vector3, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => BlocksManager.Blocks[Terrain.ExtractContents(value)].IsCollidable).HasValue)
{
pickable.Position = pickable.StuckMatrix.Value.Translation;
pickable.Velocity = Vector3.Zero;
pickable.StuckMatrix = null;
}
}
if (surfaceBlock is WaterBlock && !pickable.SplashGenerated)
{
m_subsystemParticles.AddParticleSystem(new WaterSplashParticleSystem(m_subsystemTerrain, pickable.Position, large: false));
m_subsystemAudio.PlayRandomSound("Audio/Splashes", 1f, m_random.Float(-0.2f, 0.2f), pickable.Position, 6f, autoDelay: true);
pickable.SplashGenerated = true;
}
else if (surfaceBlock is MagmaBlock && !pickable.SplashGenerated)
{
m_subsystemParticles.AddParticleSystem(new MagmaSplashParticleSystem(m_subsystemTerrain, pickable.Position, large: false));
m_subsystemAudio.PlayRandomSound("Audio/Sizzles", 1f, m_random.Float(-0.2f, 0.2f), pickable.Position, 3f, autoDelay: true);
pickable.ToRemove = true;
pickable.SplashGenerated = true;
m_subsystemExplosions.TryExplodeBlock(Terrain.ToCell(pickable.Position.X), Terrain.ToCell(pickable.Position.Y), Terrain.ToCell(pickable.Position.Z), pickable.Value);
}
else if (surfaceBlock == null)
{
pickable.SplashGenerated = false;
}
if (m_subsystemTime.PeriodicGameTimeEvent(1.0, (double)(pickable.GetHashCode() % 100) / 100.0) && (m_subsystemTerrain.Terrain.GetCellContents(Terrain.ToCell(pickable.Position.X), Terrain.ToCell(pickable.Position.Y + 0.1f), Terrain.ToCell(pickable.Position.Z)) == 104 || m_subsystemFireBlockBehavior.IsCellOnFire(Terrain.ToCell(pickable.Position.X), Terrain.ToCell(pickable.Position.Y + 0.1f), Terrain.ToCell(pickable.Position.Z))))
{
m_subsystemAudio.PlayRandomSound("Audio/Sizzles", 1f, m_random.Float(-0.2f, 0.2f), pickable.Position, 3f, autoDelay: true);
pickable.ToRemove = true;
m_subsystemExplosions.TryExplodeBlock(Terrain.ToCell(pickable.Position.X), Terrain.ToCell(pickable.Position.Y), Terrain.ToCell(pickable.Position.Z), pickable.Value);
}
if (!pickable.StuckMatrix.HasValue)
{
if (vector2.HasValue && surfaceHeight.HasValue)
{
float num19 = surfaceHeight.Value - pickable.Position.Y;
float num20 = MathUtils.Saturate(3f * num19);
pickable.Velocity.X += 4f * dt * (vector2.Value.X - pickable.Velocity.X);
pickable.Velocity.Y -= 10f * dt;
pickable.Velocity.Y += 10f * (1f / block.Density * num20) * dt;
pickable.Velocity.Z += 4f * dt * (vector2.Value.Y - pickable.Velocity.Z);
pickable.Velocity.Y *= num2;
}
else
{
pickable.Velocity.Y -= 10f * dt;
pickable.Velocity *= num;
}
}
}
pickable.Position = vector;
}
}
}
}
foreach (Pickable item in m_pickablesToRemove)
{
m_pickables.Remove(item);
if (this.PickableRemoved != null)
{
this.PickableRemoved(item);
}
}
m_pickablesToRemove.Clear();
}
