public override bool OnHitAsProjectile(CellFace?cellFace, ComponentBody componentBody, WorldItem worldItem)
{
BulletBlock.BulletType bulletType = BulletBlock.GetBulletType(Terrain.ExtractData(worldItem.Value));
bool result = true;
if (cellFace.HasValue)
{
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(cellFace.Value.X, cellFace.Value.Y, cellFace.Value.Z);
int num = Terrain.ExtractContents(cellValue);
Block obj = BlocksManager.Blocks[num];
if (worldItem.Velocity.Length() > 30f)
{
m_subsystemExplosions.TryExplodeBlock(cellFace.Value.X, cellFace.Value.Y, cellFace.Value.Z, cellValue);
}
if (obj.Density >= 1.5f && worldItem.Velocity.Length() > 30f)
{
float num2 = 1f;
float minDistance = 8f;
if (bulletType == BulletBlock.BulletType.BuckshotBall)
{
num2 = 0.25f;
minDistance = 4f;
}
if (m_random.Float(0f, 1f) < num2)
{
m_subsystemAudio.PlayRandomSound("Audio/Ricochets", 1f, m_random.Float(-0.2f, 0.2f), new Vector3(cellFace.Value.X, cellFace.Value.Y, cellFace.Value.Z), minDistance, autoDelay: true);
result = false;
}
}
}
return(result);
}
public void Update(float dt)
{
if (m_subsystemTime.PeriodicGameTimeEvent(0.1, 0.0))
{
foreach (Projectile key in m_projectiles.Keys)
{
if (m_subsystemGameInfo.TotalElapsedGameTime - key.CreationTime > 5.0)
{
m_subsystemExplosions.TryExplodeBlock(Terrain.ToCell(key.Position.X), Terrain.ToCell(key.Position.Y), Terrain.ToCell(key.Position.Z), key.Value);
key.ToRemove = true;
}
}
}
}
public void Update(float dt)
{
float num = float.MaxValue;
if (m_explosiveDataByPoint.Count > 0)
{
ExplosiveData[] array = m_explosiveDataByPoint.Values.ToArray();
foreach (ExplosiveData explosiveData in array)
{
Point3 point = explosiveData.Point;
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(point.X, point.Y, point.Z);
int num2 = Terrain.ExtractContents(cellValue);
Block block = BlocksManager.Blocks[num2];
if (explosiveData.FuseParticleSystem == null)
{
GunpowderKegBlock gunpowderKegBlock = block as GunpowderKegBlock;
if (gunpowderKegBlock != null)
{
explosiveData.FuseParticleSystem = new FuseParticleSystem(new Vector3(point.X, point.Y, point.Z) + gunpowderKegBlock.FuseOffset);
m_subsystemParticles.AddParticleSystem(explosiveData.FuseParticleSystem);
}
}
explosiveData.TimeToExplosion -= dt;
if (explosiveData.TimeToExplosion <= 0f)
{
m_subsystemExplosions.TryExplodeBlock(explosiveData.Point.X, explosiveData.Point.Y, explosiveData.Point.Z, cellValue);
}
float x = m_subsystemAudio.CalculateListenerDistance(new Vector3(point.X, point.Y, point.Z) + new Vector3(0.5f));
num = MathUtils.Min(num, x);
}
}
m_fuseSound.Volume = SettingsManager.SoundsVolume * m_subsystemAudio.CalculateVolume(num, 2f);
if (m_fuseSound.Volume > AudioManager.MinAudibleVolume)
{
m_fuseSound.Play();
}
else
{
m_fuseSound.Pause();
}
}
public override bool OnHitAsProjectile(CellFace?cellFace, ComponentBody componentBody, WorldItem worldItem)
{
return(m_subsystemExplosions.TryExplodeBlock(Terrain.ToCell(worldItem.Position.X), Terrain.ToCell(worldItem.Position.Y), Terrain.ToCell(worldItem.Position.Z), worldItem.Value));
}
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();
}
public void Update(float dt)
{
double totalElapsedGameTime = m_subsystemGameInfo.TotalElapsedGameTime;
foreach (Projectile projectile in m_projectiles)
{
if (projectile.ToRemove)
{
m_projectilesToRemove.Add(projectile);
}
else
{
Block block = BlocksManager.Blocks[Terrain.ExtractContents(projectile.Value)];
if (totalElapsedGameTime - projectile.CreationTime > 40.0)
{
projectile.ToRemove = true;
}
TerrainChunk chunkAtCell = m_subsystemTerrain.Terrain.GetChunkAtCell(Terrain.ToCell(projectile.Position.X), Terrain.ToCell(projectile.Position.Z));
if (chunkAtCell == null || chunkAtCell.State <= TerrainChunkState.InvalidContents4)
{
projectile.NoChunk = true;
if (projectile.TrailParticleSystem != null)
{
projectile.TrailParticleSystem.IsStopped = true;
}
}
else
{
projectile.NoChunk = false;
Vector3 position = projectile.Position;
Vector3 vector = position + projectile.Velocity * dt;
Vector3 v = block.ProjectileTipOffset * Vector3.Normalize(projectile.Velocity);
BodyRaycastResult? bodyRaycastResult = m_subsystemBodies.Raycast(position + v, vector + v, 0.2f, (ComponentBody body, float distance) => true);
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(position + v, vector + v, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => BlocksManager.Blocks[Terrain.ExtractContents(value)].IsCollidable);
bool flag = block.DisintegratesOnHit;
if (terrainRaycastResult.HasValue || bodyRaycastResult.HasValue)
{
CellFace? cellFace = terrainRaycastResult.HasValue ? new CellFace?(terrainRaycastResult.Value.CellFace) : null;
ComponentBody componentBody = bodyRaycastResult.HasValue ? bodyRaycastResult.Value.ComponentBody : null;
SubsystemBlockBehavior[] blockBehaviors = m_subsystemBlockBehaviors.GetBlockBehaviors(Terrain.ExtractContents(projectile.Value));
for (int i = 0; i < blockBehaviors.Length; i++)
{
flag |= blockBehaviors[i].OnHitAsProjectile(cellFace, componentBody, projectile);
}
projectile.ToRemove |= flag;
}
Vector3?vector2 = null;
if (bodyRaycastResult.HasValue && (!terrainRaycastResult.HasValue || bodyRaycastResult.Value.Distance < terrainRaycastResult.Value.Distance))
{
if (projectile.Velocity.Length() > 10f)
{
ComponentMiner.AttackBody(bodyRaycastResult.Value.ComponentBody, projectile.Owner, bodyRaycastResult.Value.HitPoint(), Vector3.Normalize(projectile.Velocity), block.GetProjectilePower(projectile.Value), isMeleeAttack: false);
if (projectile.Owner != null && projectile.Owner.PlayerStats != null)
{
projectile.Owner.PlayerStats.RangedHits++;
}
}
if (projectile.IsIncendiary)
{
bodyRaycastResult.Value.ComponentBody.Entity.FindComponent <ComponentOnFire>()?.SetOnFire(projectile?.Owner, m_random.Float(6f, 8f));
}
vector = position;
projectile.Velocity *= -0.05f;
projectile.Velocity += m_random.Vector3(0.33f * projectile.Velocity.Length());
projectile.AngularVelocity *= -0.05f;
}
else if (terrainRaycastResult.HasValue)
{
CellFace cellFace2 = terrainRaycastResult.Value.CellFace;
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(cellFace2.X, cellFace2.Y, cellFace2.Z);
int num = Terrain.ExtractContents(cellValue);
Block block2 = BlocksManager.Blocks[num];
float num2 = projectile.Velocity.Length();
SubsystemBlockBehavior[] blockBehaviors2 = m_subsystemBlockBehaviors.GetBlockBehaviors(num);
for (int j = 0; j < blockBehaviors2.Length; j++)
{
blockBehaviors2[j].OnHitByProjectile(cellFace2, projectile);
}
if (num2 > 10f && m_random.Float(0f, 1f) > block2.ProjectileResilience)
{
m_subsystemTerrain.DestroyCell(0, cellFace2.X, cellFace2.Y, cellFace2.Z, 0, noDrop: true, noParticleSystem: false);
m_subsystemSoundMaterials.PlayImpactSound(cellValue, position, 1f);
}
if (projectile.IsIncendiary)
{
m_subsystemFireBlockBehavior.SetCellOnFire(terrainRaycastResult.Value.CellFace.X, terrainRaycastResult.Value.CellFace.Y, terrainRaycastResult.Value.CellFace.Z, 1f);
Vector3 vector3 = projectile.Position - 0.75f * Vector3.Normalize(projectile.Velocity);
for (int k = 0; k < 8; k++)
{
Vector3 v2 = (k == 0) ? Vector3.Normalize(projectile.Velocity) : m_random.Vector3(1.5f);
TerrainRaycastResult?terrainRaycastResult2 = m_subsystemTerrain.Raycast(vector3, vector3 + v2, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => true);
if (terrainRaycastResult2.HasValue)
{
m_subsystemFireBlockBehavior.SetCellOnFire(terrainRaycastResult2.Value.CellFace.X, terrainRaycastResult2.Value.CellFace.Y, terrainRaycastResult2.Value.CellFace.Z, 1f);
}
}
}
if (num2 > 5f)
{
m_subsystemSoundMaterials.PlayImpactSound(cellValue, position, 1f);
}
if (block.IsStickable && num2 > 10f && m_random.Bool(block2.ProjectileStickProbability))
{
Vector3 v3 = Vector3.Normalize(projectile.Velocity);
float s = MathUtils.Lerp(0.1f, 0.2f, MathUtils.Saturate((num2 - 15f) / 20f));
vector2 = position + terrainRaycastResult.Value.Distance * Vector3.Normalize(projectile.Velocity) + v3 * s;
}
else
{
Plane plane = cellFace2.CalculatePlane();
vector = position;
if (plane.Normal.X != 0f)
{
projectile.Velocity *= new Vector3(-0.3f, 0.3f, 0.3f);
}
if (plane.Normal.Y != 0f)
{
projectile.Velocity *= new Vector3(0.3f, -0.3f, 0.3f);
}
if (plane.Normal.Z != 0f)
{
projectile.Velocity *= new Vector3(0.3f, 0.3f, -0.3f);
}
float num3 = projectile.Velocity.Length();
projectile.Velocity = num3 * Vector3.Normalize(projectile.Velocity + m_random.Vector3(num3 / 6f, num3 / 3f));
projectile.AngularVelocity *= -0.3f;
}
MakeProjectileNoise(projectile);
}
if (terrainRaycastResult.HasValue || bodyRaycastResult.HasValue)
{
if (flag)
{
m_subsystemParticles.AddParticleSystem(block.CreateDebrisParticleSystem(m_subsystemTerrain, projectile.Position, projectile.Value, 1f));
}
else if (!projectile.ToRemove && (vector2.HasValue || projectile.Velocity.Length() < 1f))
{
if (projectile.ProjectileStoppedAction == ProjectileStoppedAction.TurnIntoPickable)
{
int num4 = BlocksManager.DamageItem(projectile.Value, 1);
if (num4 != 0)
{
if (vector2.HasValue)
{
CalculateVelocityAlignMatrix(block, vector2.Value, projectile.Velocity, out Matrix matrix);
m_subsystemPickables.AddPickable(num4, 1, projectile.Position, Vector3.Zero, matrix);
}
else
{
m_subsystemPickables.AddPickable(num4, 1, position, Vector3.Zero, null);
}
}
projectile.ToRemove = true;
}
else if (projectile.ProjectileStoppedAction == ProjectileStoppedAction.Disappear)
{
projectile.ToRemove = true;
}
}
}
float num5 = projectile.IsInWater ? MathUtils.Pow(0.001f, dt) : MathUtils.Pow(block.ProjectileDamping, dt);
projectile.Velocity.Y += -10f * dt;
projectile.Velocity *= num5;
projectile.AngularVelocity *= num5;
projectile.Position = vector;
projectile.Rotation += projectile.AngularVelocity * dt;
if (projectile.TrailParticleSystem != null)
{
if (!m_subsystemParticles.ContainsParticleSystem((ParticleSystemBase)projectile.TrailParticleSystem))
{
m_subsystemParticles.AddParticleSystem((ParticleSystemBase)projectile.TrailParticleSystem);
}
Vector3 v4 = (projectile.TrailOffset != Vector3.Zero) ? Vector3.TransformNormal(projectile.TrailOffset, Matrix.CreateFromAxisAngle(Vector3.Normalize(projectile.Rotation), projectile.Rotation.Length())) : Vector3.Zero;
projectile.TrailParticleSystem.Position = projectile.Position + v4;
if (projectile.IsInWater)
{
projectile.TrailParticleSystem.IsStopped = true;
}
}
bool flag2 = IsWater(projectile.Position);
if (projectile.IsInWater != flag2)
{
if (flag2)
{
float num6 = new Vector2(projectile.Velocity.X + projectile.Velocity.Z).Length();
if (num6 > 6f && num6 > 4f * MathUtils.Abs(projectile.Velocity.Y))
{
projectile.Velocity *= 0.5f;
projectile.Velocity.Y *= -1f;
flag2 = false;
}
else
{
projectile.Velocity *= 0.2f;
}
float?surfaceHeight = m_subsystemFluidBlockBehavior.GetSurfaceHeight(Terrain.ToCell(projectile.Position.X), Terrain.ToCell(projectile.Position.Y), Terrain.ToCell(projectile.Position.Z));
if (surfaceHeight.HasValue)
{
m_subsystemParticles.AddParticleSystem(new WaterSplashParticleSystem(m_subsystemTerrain, new Vector3(projectile.Position.X, surfaceHeight.Value, projectile.Position.Z), large: false));
m_subsystemAudio.PlayRandomSound("Audio/Splashes", 1f, m_random.Float(-0.2f, 0.2f), projectile.Position, 6f, autoDelay: true);
MakeProjectileNoise(projectile);
}
}
projectile.IsInWater = flag2;
}
if (IsMagma(projectile.Position))
{
m_subsystemParticles.AddParticleSystem(new MagmaSplashParticleSystem(m_subsystemTerrain, projectile.Position, large: false));
m_subsystemAudio.PlayRandomSound("Audio/Sizzles", 1f, m_random.Float(-0.2f, 0.2f), projectile.Position, 3f, autoDelay: true);
projectile.ToRemove = true;
m_subsystemExplosions.TryExplodeBlock(Terrain.ToCell(projectile.Position.X), Terrain.ToCell(projectile.Position.Y), Terrain.ToCell(projectile.Position.Z), projectile.Value);
}
if (m_subsystemTime.PeriodicGameTimeEvent(1.0, (double)(projectile.GetHashCode() % 100) / 100.0) && (m_subsystemFireBlockBehavior.IsCellOnFire(Terrain.ToCell(projectile.Position.X), Terrain.ToCell(projectile.Position.Y + 0.1f), Terrain.ToCell(projectile.Position.Z)) || m_subsystemFireBlockBehavior.IsCellOnFire(Terrain.ToCell(projectile.Position.X), Terrain.ToCell(projectile.Position.Y + 0.1f) - 1, Terrain.ToCell(projectile.Position.Z))))
{
m_subsystemAudio.PlayRandomSound("Audio/Sizzles", 1f, m_random.Float(-0.2f, 0.2f), projectile.Position, 3f, autoDelay: true);
projectile.ToRemove = true;
m_subsystemExplosions.TryExplodeBlock(Terrain.ToCell(projectile.Position.X), Terrain.ToCell(projectile.Position.Y), Terrain.ToCell(projectile.Position.Z), projectile.Value);
}
}
}
}
foreach (Projectile item in m_projectilesToRemove)
{
if (item.TrailParticleSystem != null)
{
item.TrailParticleSystem.IsStopped = true;
}
m_projectiles.Remove(item);
if (this.ProjectileRemoved != null)
{
this.ProjectileRemoved(item);
}
}
m_projectilesToRemove.Clear();
}
public void Update(float dt)
{
Point3 coordinates = m_componentBlockEntity.Coordinates;
if (m_heatLevel > 0f)
{
m_fireTimeRemaining = MathUtils.Max(0f, m_fireTimeRemaining - dt);
if (m_fireTimeRemaining == 0f)
{
m_heatLevel = 0f;
}
}
if (m_updateSmeltingRecipe)
{
m_updateSmeltingRecipe = false;
float heatLevel = 0f;
if (m_heatLevel > 0f)
{
heatLevel = m_heatLevel;
}
else
{
Slot slot = m_slots[FuelSlotIndex];
if (slot.Count > 0)
{
int num = Terrain.ExtractContents(slot.Value);
heatLevel = BlocksManager.Blocks[num].FuelHeatLevel;
}
}
CraftingRecipe craftingRecipe = FindSmeltingRecipe(heatLevel);
if (craftingRecipe != m_smeltingRecipe)
{
m_smeltingRecipe = ((craftingRecipe != null && craftingRecipe.ResultValue != 0) ? craftingRecipe : null);
m_smeltingProgress = 0f;
}
}
if (m_smeltingRecipe == null)
{
m_heatLevel = 0f;
m_fireTimeRemaining = 0f;
}
if (m_smeltingRecipe != null && m_fireTimeRemaining <= 0f)
{
Slot slot2 = m_slots[FuelSlotIndex];
if (slot2.Count > 0)
{
int num2 = Terrain.ExtractContents(slot2.Value);
Block block = BlocksManager.Blocks[num2];
if (block.GetExplosionPressure(slot2.Value) > 0f)
{
slot2.Count = 0;
m_subsystemExplosions.TryExplodeBlock(coordinates.X, coordinates.Y, coordinates.Z, slot2.Value);
}
else if (block.FuelHeatLevel > 0f)
{
slot2.Count--;
m_fireTimeRemaining = block.FuelFireDuration;
m_heatLevel = block.FuelHeatLevel;
}
}
}
if (m_fireTimeRemaining <= 0f)
{
m_smeltingRecipe = null;
m_smeltingProgress = 0f;
}
if (m_smeltingRecipe != null)
{
m_smeltingProgress = MathUtils.Min(m_smeltingProgress + 0.15f * dt, 1f);
if (m_smeltingProgress >= 1f)
{
for (int i = 0; i < m_furnaceSize; i++)
{
if (m_slots[i].Count > 0)
{
m_slots[i].Count--;
}
}
m_slots[ResultSlotIndex].Value = m_smeltingRecipe.ResultValue;
m_slots[ResultSlotIndex].Count += m_smeltingRecipe.ResultCount;
if (m_smeltingRecipe.RemainsValue != 0 && m_smeltingRecipe.RemainsCount > 0)
{
m_slots[RemainsSlotIndex].Value = m_smeltingRecipe.RemainsValue;
m_slots[RemainsSlotIndex].Count += m_smeltingRecipe.RemainsCount;
}
m_smeltingRecipe = null;
m_smeltingProgress = 0f;
m_updateSmeltingRecipe = true;
}
}
TerrainChunk chunkAtCell = m_subsystemTerrain.Terrain.GetChunkAtCell(coordinates.X, coordinates.Z);
if (chunkAtCell != null && chunkAtCell.State == TerrainChunkState.Valid)
{
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(coordinates.X, coordinates.Y, coordinates.Z);
m_subsystemTerrain.ChangeCell(coordinates.X, coordinates.Y, coordinates.Z, Terrain.ReplaceContents(cellValue, (m_heatLevel > 0f) ? 65 : 64));
}
}