public override void OnNeighborBlockChanged(int x, int y, int z, int neighborX, int neighborY, int neighborZ)
{
int cellContents = base.SubsystemTerrain.Terrain.GetCellContents(neighborX, neighborY, neighborZ);
if (cellContents != 0 && cellContents != 18)
{
return;
}
base.SubsystemTerrain.ChangeCell(x, y, z, Terrain.MakeBlockValue(0));
if (!m_random.Bool(0.25f))
{
return;
}
int num = 0;
int num2 = 0;
float max = m_treasureData.Sum((TreasureData t) => t.Probability);
float num3 = m_random.Float(0f, max);
TreasureData[] treasureData = m_treasureData;
for (int i = 0; i < treasureData.Length; i++)
{
TreasureData treasureData2 = treasureData[i];
num3 -= treasureData2.Probability;
if (num3 <= 0f)
{
num = treasureData2.Value;
num2 = m_random.Int(1, treasureData2.MaxCount);
break;
}
}
if (num != 0 && num2 > 0)
{
for (int j = 0; j < num2; j++)
{
m_subsystemPickables.AddPickable(num, 1, new Vector3(x, y, z) + m_random.Vector3(0.1f, 0.4f) + new Vector3(0.5f), Vector3.Zero, null);
}
int num4 = m_random.Int(3, 6);
for (int k = 0; k < num4; k++)
{
m_subsystemPickables.AddPickable(248, 1, new Vector3(x, y, z) + m_random.Vector3(0.1f, 0.4f) + new Vector3(0.5f), Vector3.Zero, null);
}
}
}
public void DropAllItems(Vector3 position)
{
Random random = new Random();
SubsystemPickables subsystemPickables = base.Project.FindSubsystem <SubsystemPickables>(throwOnError: true);
for (int i = 0; i < SlotsCount; i++)
{
int slotCount = GetSlotCount(i);
if (slotCount > 0)
{
int slotValue = GetSlotValue(i);
int count = RemoveSlotItems(i, slotCount);
Vector3 value = random.Float(5f, 10f) * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(1f, 2f), random.Float(-1f, 1f)));
subsystemPickables.AddPickable(slotValue, count, position, value, null);
}
}
}
public void DragDrop(Widget dragWidget, object data)
{
InventoryDragData inventoryDragData = data as InventoryDragData;
if (inventoryDragData != null && GameManager.Project != null)
{
SubsystemPickables subsystemPickables = GameManager.Project.FindSubsystem <SubsystemPickables>(throwOnError: true);
ComponentPlayer componentPlayer = GameWidget.PlayerData.ComponentPlayer;
int slotValue = inventoryDragData.Inventory.GetSlotValue(inventoryDragData.SlotIndex);
int count = (componentPlayer != null && componentPlayer.ComponentInput.SplitSourceInventory == inventoryDragData.Inventory && componentPlayer.ComponentInput.SplitSourceSlotIndex == inventoryDragData.SlotIndex) ? 1 : ((inventoryDragData.DragMode != DragMode.SingleItem) ? inventoryDragData.Inventory.GetSlotCount(inventoryDragData.SlotIndex) : MathUtils.Min(inventoryDragData.Inventory.GetSlotCount(inventoryDragData.SlotIndex), 1));
int num = inventoryDragData.Inventory.RemoveSlotItems(inventoryDragData.SlotIndex, count);
if (num > 0)
{
Vector2 vector = dragWidget.WidgetToScreen(dragWidget.ActualSize / 2f);
Vector3 value = Vector3.Normalize(GameWidget.ActiveCamera.ScreenToWorld(new Vector3(vector.X, vector.Y, 1f), Matrix.Identity) - GameWidget.ActiveCamera.ViewPosition) * 12f;
subsystemPickables.AddPickable(slotValue, num, GameWidget.ActiveCamera.ViewPosition, value, null);
}
}
}
public void Update(float dt)
{
if (!m_lootDropped && m_componentCreature.ComponentHealth.DeathTime.HasValue && m_subsystemGameInfo.TotalElapsedGameTime >= m_componentCreature.ComponentHealth.DeathTime.Value + (double)m_componentCreature.ComponentHealth.CorpseDuration)
{
bool num = m_componentCreature.Entity.FindComponent <ComponentOnFire>()?.IsOnFire ?? false;
m_lootDropped = true;
foreach (Loot item in num ? m_lootOnFireList : m_lootList)
{
if (m_random.Float(0f, 1f) < item.Probability)
{
int num2 = m_random.Int(item.MinCount, item.MaxCount);
for (int i = 0; i < num2; i++)
{
Vector3 position = (m_componentCreature.ComponentBody.BoundingBox.Min + m_componentCreature.ComponentBody.BoundingBox.Max) / 2f;
m_subsystemPickables.AddPickable(item.Value, 1, position, null, null);
}
}
}
}
}
public void DestroyCell(int toolLevel, int x, int y, int z, int newValue, bool noDrop, bool noParticleSystem)
{
int cellValue = Terrain.GetCellValue(x, y, z);
int num = Terrain.ExtractContents(cellValue);
Block block = BlocksManager.Blocks[num];
if (num != 0)
{
bool showDebris = true;
if (!noDrop)
{
m_dropValues.Clear();
block.GetDropValues(this, cellValue, newValue, toolLevel, m_dropValues, out showDebris);
for (int i = 0; i < m_dropValues.Count; i++)
{
BlockDropValue dropValue = m_dropValues[i];
if (dropValue.Count > 0)
{
SubsystemBlockBehavior[] blockBehaviors = m_subsystemBlockBehaviors.GetBlockBehaviors(Terrain.ExtractContents(dropValue.Value));
for (int j = 0; j < blockBehaviors.Length; j++)
{
blockBehaviors[j].OnItemHarvested(x, y, z, cellValue, ref dropValue, ref newValue);
}
if (dropValue.Count > 0 && Terrain.ExtractContents(dropValue.Value) != 0)
{
Vector3 position = new Vector3(x, y, z) + new Vector3(0.5f);
m_subsystemPickables.AddPickable(dropValue.Value, dropValue.Count, position, null, null);
}
}
}
}
if (showDebris && !noParticleSystem && m_subsystemViews.CalculateDistanceFromNearestView(new Vector3(x, y, z)) < 16f)
{
m_subsystemParticles.AddParticleSystem(block.CreateDebrisParticleSystem(this, new Vector3((float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f), cellValue, 1f));
}
}
ChangeCell(x, y, z, newValue);
}
public void DispenseItem(Point3 point, int face, int value, DispenserBlock.Mode mode)
{
Vector3 vector = CellFace.FaceToVector3(face);
Vector3 position = new Vector3((float)point.X + 0.5f, (float)point.Y + 0.5f, (float)point.Z + 0.5f) + 0.6f * vector;
if (mode == DispenserBlock.Mode.Dispense)
{
float s = 1.8f;
m_subsystemPickables.AddPickable(value, 1, position, s * (vector + m_random.Vector3(0.2f)), null);
m_subsystemAudio.PlaySound("Audio/DispenserDispense", 1f, 0f, new Vector3(position.X, position.Y, position.Z), 3f, autoDelay: true);
return;
}
float s2 = m_random.Float(39f, 41f);
if (m_subsystemProjectiles.FireProjectile(value, position, s2 * (vector + m_random.Vector3(0.025f) + new Vector3(0f, 0.05f, 0f)), Vector3.Zero, null) != null)
{
m_subsystemAudio.PlaySound("Audio/DispenserShoot", 1f, 0f, new Vector3(position.X, position.Y, position.Z), 4f, autoDelay: true);
}
else
{
DispenseItem(point, face, value, DispenserBlock.Mode.Dispense);
}
}
public override void Load(ValuesDictionary valuesDictionary, IdToEntityMap idToEntityMap)
{
m_subsystemTime = base.Project.FindSubsystem <SubsystemTime>(throwOnError: true);
m_subsystemTerrain = base.Project.FindSubsystem <SubsystemTerrain>(throwOnError: true);
m_subsystemPickables = base.Project.FindSubsystem <SubsystemPickables>(throwOnError: true);
m_subsystemAudio = base.Project.FindSubsystem <SubsystemAudio>(throwOnError: true);
m_componentCreature = base.Entity.FindComponent <ComponentCreature>(throwOnError: true);
m_componentPathfinding = base.Entity.FindComponent <ComponentPathfinding>(throwOnError: true);
EggBlock eggBlock = (EggBlock)BlocksManager.Blocks[118];
m_layFrequency = valuesDictionary.GetValue <float>("LayFrequency");
m_eggType = eggBlock.GetEggTypeByCreatureTemplateName(base.Entity.ValuesDictionary.DatabaseObject.Name);
m_stateMachine.AddState("Inactive", null, delegate
{
if (IsActive)
{
m_stateMachine.TransitionTo("Move");
}
}, null);
m_stateMachine.AddState("Stuck", delegate
{
m_stateMachine.TransitionTo("Move");
}, null, null);
m_stateMachine.AddState("Move", delegate
{
Vector3 position2 = m_componentCreature.ComponentBody.Position;
float num = 5f;
Vector3 value3 = position2 + new Vector3(num * m_random.Float(-1f, 1f), 0f, num * m_random.Float(-1f, 1f));
value3.Y = m_subsystemTerrain.Terrain.GetTopHeight(Terrain.ToCell(value3.X), Terrain.ToCell(value3.Z)) + 1;
m_componentPathfinding.SetDestination(value3, m_random.Float(0.4f, 0.6f), 0.5f, 0, useRandomMovements: false, ignoreHeightDifference: true, raycastDestination: false, null);
}, delegate
{
if (!m_componentPathfinding.Destination.HasValue)
{
m_stateMachine.TransitionTo("Lay");
}
else if (m_componentPathfinding.IsStuck)
{
if (m_random.Float(0f, 1f) < 0.5f)
{
m_stateMachine.TransitionTo("Stuck");
}
else
{
m_importanceLevel = 0f;
}
}
}, null);
m_stateMachine.AddState("Lay", delegate
{
m_layTime = 0f;
}, delegate
{
if (m_eggType != null)
{
m_layTime += m_dt;
if (m_componentCreature.ComponentBody.StandingOnValue.HasValue)
{
m_componentCreature.ComponentLocomotion.LookOrder = new Vector2(0f, 0.25f * (float)MathUtils.Sin(20.0 * m_subsystemTime.GameTime) + m_layTime / 3f) - m_componentCreature.ComponentLocomotion.LookAngles;
if (m_layTime >= 3f)
{
m_importanceLevel = 0f;
int value = Terrain.MakeBlockValue(118, 0, EggBlock.SetIsLaid(EggBlock.SetEggType(0, m_eggType.EggTypeIndex), isLaid: true));
Matrix matrix = m_componentCreature.ComponentBody.Matrix;
Vector3 position = 0.5f * (m_componentCreature.ComponentBody.BoundingBox.Min + m_componentCreature.ComponentBody.BoundingBox.Max);
Vector3 value2 = 3f * Vector3.Normalize(-matrix.Forward + 0.1f * matrix.Up + 0.2f * m_random.Float(-1f, 1f) * matrix.Right);
m_subsystemPickables.AddPickable(value, 1, position, value2, null);
m_subsystemAudio.PlaySound("Audio/EggLaid", 1f, m_random.Float(-0.1f, 0.1f), position, 2f, autoDelay: true);
}
}
else if (m_layTime >= 3f)
{
m_importanceLevel = 0f;
}
}
else
{
m_importanceLevel = 0f;
}
}, null);
}
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 ScanDesign(CellFace start, Vector3 direction, ComponentMiner componentMiner)
{
FurnitureDesign design = null;
FurnitureDesign furnitureDesign = null;
Dictionary <Point3, int> valuesDictionary = new Dictionary <Point3, int>();
Point3 point = start.Point;
Point3 point2 = start.Point;
int startValue = base.SubsystemTerrain.Terrain.GetCellValue(start.Point.X, start.Point.Y, start.Point.Z);
int num = Terrain.ExtractContents(startValue);
if (BlocksManager.Blocks[num] is FurnitureBlock)
{
int designIndex = FurnitureBlock.GetDesignIndex(Terrain.ExtractData(startValue));
furnitureDesign = GetDesign(designIndex);
if (furnitureDesign == null)
{
componentMiner.ComponentPlayer?.ComponentGui.DisplaySmallMessage("Unsuitable block found", Color.White, blinking: true, playNotificationSound: false);
return;
}
design = furnitureDesign.Clone();
design.LinkedDesign = null;
design.InteractionMode = FurnitureInteractionMode.None;
valuesDictionary.Add(start.Point, startValue);
}
else
{
Stack <Point3> val = new Stack <Point3>();
val.Push(start.Point);
while (val.Count > 0)
{
Point3 key = val.Pop();
if (valuesDictionary.ContainsKey(key))
{
continue;
}
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(key.X, key.Y, key.Z);
if (IsValueDisallowed(cellValue))
{
componentMiner.ComponentPlayer?.ComponentGui.DisplaySmallMessage("Unsuitable block found", Color.White, blinking: true, playNotificationSound: false);
return;
}
if (IsValueAllowed(cellValue))
{
if (key.X < point.X)
{
point.X = key.X;
}
if (key.Y < point.Y)
{
point.Y = key.Y;
}
if (key.Z < point.Z)
{
point.Z = key.Z;
}
if (key.X > point2.X)
{
point2.X = key.X;
}
if (key.Y > point2.Y)
{
point2.Y = key.Y;
}
if (key.Z > point2.Z)
{
point2.Z = key.Z;
}
if (MathUtils.Abs(point.X - point2.X) >= 16 || MathUtils.Abs(point.Y - point2.Y) >= 16 || MathUtils.Abs(point.Z - point2.Z) >= 16)
{
componentMiner.ComponentPlayer?.ComponentGui.DisplaySmallMessage("Furniture design is too large", Color.White, blinking: true, playNotificationSound: false);
return;
}
valuesDictionary[key] = cellValue;
val.Push(new Point3(key.X - 1, key.Y, key.Z));
val.Push(new Point3(key.X + 1, key.Y, key.Z));
val.Push(new Point3(key.X, key.Y - 1, key.Z));
val.Push(new Point3(key.X, key.Y + 1, key.Z));
val.Push(new Point3(key.X, key.Y, key.Z - 1));
val.Push(new Point3(key.X, key.Y, key.Z + 1));
}
}
if (valuesDictionary.Count == 0)
{
componentMiner.ComponentPlayer?.ComponentGui.DisplaySmallMessage("No suitable blocks found", Color.White, blinking: true, playNotificationSound: false);
return;
}
design = new FurnitureDesign(base.SubsystemTerrain);
Point3 point3 = point2 - point;
int num2 = MathUtils.Max(MathUtils.Max(point3.X, point3.Y, point3.Z) + 1, 2);
int[] array = new int[num2 * num2 * num2];
foreach (KeyValuePair <Point3, int> item in valuesDictionary)
{
Point3 point4 = item.Key - point;
array[point4.X + point4.Y * num2 + point4.Z * num2 * num2] = item.Value;
}
design.SetValues(num2, array);
int steps = (start.Face > 3) ? CellFace.Vector3ToFace(direction, 3) : CellFace.OppositeFace(start.Face);
design.Rotate(1, steps);
Point3 location = design.Box.Location;
Point3 point5 = new Point3(design.Resolution) - (design.Box.Location + design.Box.Size);
Point3 delta = new Point3((point5.X - location.X) / 2, -location.Y, (point5.Z - location.Z) / 2);
design.Shift(delta);
}
BuildFurnitureDialog dialog = new BuildFurnitureDialog(design, furnitureDesign, delegate(bool result)
{
if (result)
{
design = TryAddDesign(design);
if (design == null)
{
componentMiner.ComponentPlayer?.ComponentGui.DisplaySmallMessage("Too many different furniture designs", Color.White, blinking: true, playNotificationSound: false);
}
else
{
if (m_subsystemGameInfo.WorldSettings.GameMode != 0)
{
foreach (KeyValuePair <Point3, int> item2 in valuesDictionary)
{
base.SubsystemTerrain.DestroyCell(0, item2.Key.X, item2.Key.Y, item2.Key.Z, 0, noDrop: true, noParticleSystem: true);
}
}
int value = Terrain.MakeBlockValue(227, 0, FurnitureBlock.SetDesignIndex(0, design.Index, design.ShadowStrengthFactor, design.IsLightEmitter));
int num3 = MathUtils.Clamp(design.Resolution, 4, 8);
Matrix matrix = componentMiner.ComponentCreature.ComponentBody.Matrix;
Vector3 position = matrix.Translation + 1f * matrix.Forward + 1f * Vector3.UnitY;
m_subsystemPickables.AddPickable(value, num3, position, null, null);
componentMiner.DamageActiveTool(1);
componentMiner.Poke(forceRestart: false);
for (int i = 0; i < 3; i++)
{
Time.QueueTimeDelayedExecution(Time.FrameStartTime + (double)((float)i * 0.25f), delegate
{
m_subsystemSoundMaterials.PlayImpactSound(startValue, new Vector3(start.Point), 1f);
});
}
if (componentMiner.ComponentCreature.PlayerStats != null)
{
componentMiner.ComponentCreature.PlayerStats.FurnitureItemsMade += num3;
}
}
}
});
if (componentMiner.ComponentPlayer != null)
{
DialogsManager.ShowDialog(componentMiner.ComponentPlayer.GuiWidget, dialog);
}
}
public void Update(float dt)
{
if (m_subsystemGameInfo.WorldSettings.GameMode != 0 && m_subsystemGameInfo.WorldSettings.AreAdventureSurvivalMechanicsEnabled && m_subsystemTime.PeriodicGameTimeEvent(0.5, 0.0))
{
foreach (int enumValue in EnumUtils.GetEnumValues(typeof(ClothingSlot)))
{
bool flag = false;
m_clothesList.Clear();
m_clothesList.AddRange(GetClothes((ClothingSlot)enumValue));
int num = 0;
while (num < m_clothesList.Count)
{
int value = m_clothesList[num];
ClothingData clothingData = ClothingBlock.GetClothingData(Terrain.ExtractData(value));
if ((float)clothingData.PlayerLevelRequired > m_componentPlayer.PlayerData.Level)
{
m_componentGui.DisplaySmallMessage(string.Format(LanguageControl.Get(fName, 1), clothingData.PlayerLevelRequired, clothingData.DisplayName), Color.White, blinking: true, playNotificationSound: true);
m_subsystemPickables.AddPickable(value, 1, m_componentBody.Position, null, null);
m_clothesList.RemoveAt(num);
flag = true;
}
else
{
num++;
}
}
if (flag)
{
SetClothes((ClothingSlot)enumValue, m_clothesList);
}
}
}
if (m_subsystemGameInfo.WorldSettings.GameMode != 0 && m_subsystemGameInfo.WorldSettings.AreAdventureSurvivalMechanicsEnabled && m_subsystemTime.PeriodicGameTimeEvent(2.0, 0.0) && ((m_componentLocomotion.LastWalkOrder.HasValue && m_componentLocomotion.LastWalkOrder.Value != Vector2.Zero) || (m_componentLocomotion.LastSwimOrder.HasValue && m_componentLocomotion.LastSwimOrder.Value != Vector3.Zero) || m_componentLocomotion.LastJumpOrder != 0f))
{
if (m_lastTotalElapsedGameTime.HasValue)
{
foreach (int enumValue2 in EnumUtils.GetEnumValues(typeof(ClothingSlot)))
{
bool flag2 = false;
m_clothesList.Clear();
m_clothesList.AddRange(GetClothes((ClothingSlot)enumValue2));
for (int i = 0; i < m_clothesList.Count; i++)
{
int value2 = m_clothesList[i];
ClothingData clothingData2 = ClothingBlock.GetClothingData(Terrain.ExtractData(value2));
float num2 = (m_componentVitalStats.Wetness > 0f) ? (10f * clothingData2.Sturdiness) : (20f * clothingData2.Sturdiness);
double num3 = MathUtils.Floor(m_lastTotalElapsedGameTime.Value / (double)num2);
if (MathUtils.Floor(m_subsystemGameInfo.TotalElapsedGameTime / (double)num2) > num3 && m_random.Float(0f, 1f) < 0.75f)
{
m_clothesList[i] = BlocksManager.DamageItem(value2, 1);
flag2 = true;
}
}
int num4 = 0;
while (num4 < m_clothesList.Count)
{
if (Terrain.ExtractContents(m_clothesList[num4]) != 203)
{
m_clothesList.RemoveAt(num4);
m_subsystemParticles.AddParticleSystem(new BlockDebrisParticleSystem(m_subsystemTerrain, m_componentBody.Position + m_componentBody.BoxSize / 2f, 1f, 1f, Color.White, 0));
m_componentGui.DisplaySmallMessage(LanguageControl.Get(fName, 2), Color.White, blinking: true, playNotificationSound: true);
}
else
{
num4++;
}
}
if (flag2)
{
SetClothes((ClothingSlot)enumValue2, m_clothesList);
}
}
}
m_lastTotalElapsedGameTime = m_subsystemGameInfo.TotalElapsedGameTime;
}
UpdateRenderTargets();
}
public void Injure(float amount, ComponentCreature attacker, bool ignoreInvulnerability, string cause)
{
if (!(amount > 0f) || (!ignoreInvulnerability && IsInvulnerable))
{
return;
}
if (Health > 0f)
{
if (m_componentCreature.PlayerStats != null)
{
if (attacker != null)
{
m_componentCreature.PlayerStats.HitsReceived++;
}
m_componentCreature.PlayerStats.TotalHealthLost += MathUtils.Min(amount, Health);
}
Health = MathUtils.Max(Health - amount, 0f);
if (Health <= 0f)
{
CauseOfDeath = cause;
if (m_componentCreature.PlayerStats != null)
{
m_componentCreature.PlayerStats.AddDeathRecord(new PlayerStats.DeathRecord
{
Day = m_subsystemTimeOfDay.Day,
Location = m_componentCreature.ComponentBody.Position,
Cause = cause
});
}
if (attacker != null)
{
ComponentPlayer componentPlayer = attacker.Entity.FindComponent <ComponentPlayer>();
if (componentPlayer != null)
{
if (m_componentPlayer != null)
{
componentPlayer.PlayerStats.PlayerKills++;
}
else if (m_componentCreature.Category == CreatureCategory.LandPredator || m_componentCreature.Category == CreatureCategory.LandOther)
{
componentPlayer.PlayerStats.LandCreatureKills++;
}
else if (m_componentCreature.Category == CreatureCategory.WaterPredator || m_componentCreature.Category == CreatureCategory.WaterOther)
{
componentPlayer.PlayerStats.WaterCreatureKills++;
}
else
{
componentPlayer.PlayerStats.AirCreatureKills++;
}
int num = (int)MathUtils.Ceiling(m_componentCreature.ComponentHealth.AttackResilience / 12f);
for (int i = 0; i < num; i++)
{
Vector2 vector = m_random.Vector2(2.5f, 3.5f);
m_subsystemPickables.AddPickable(248, 1, m_componentCreature.ComponentBody.Position, new Vector3(vector.X, 6f, vector.Y), null);
}
}
}
}
}
if (attacker != null && this.Attacked != null)
{
this.Attacked(attacker);
}
}
public void Update(float dt)
{
PlayerInput playerInput = ComponentInput.PlayerInput;
if (ComponentInput.IsControlledByTouch && m_aim.HasValue)
{
playerInput.Look = Vector2.Zero;
}
if (ComponentMiner.Inventory != null)
{
ComponentMiner.Inventory.ActiveSlotIndex += playerInput.ScrollInventory;
if (playerInput.SelectInventorySlot.HasValue)
{
ComponentMiner.Inventory.ActiveSlotIndex = MathUtils.Clamp(playerInput.SelectInventorySlot.Value, 0, 9);
}
}
ComponentSteedBehavior componentSteedBehavior = null;
ComponentBoat componentBoat = null;
ComponentMount mount = ComponentRider.Mount;
if (mount != null)
{
componentSteedBehavior = mount.Entity.FindComponent <ComponentSteedBehavior>();
componentBoat = mount.Entity.FindComponent <ComponentBoat>();
}
if (componentSteedBehavior != null)
{
if (playerInput.Move.Z > 0.5f && !m_speedOrderBlocked)
{
if (PlayerData.PlayerClass == PlayerClass.Male)
{
m_subsystemAudio.PlayRandomSound("Audio/Creatures/MaleYellFast", 0.75f, 0f, base.ComponentBody.Position, 2f, autoDelay: false);
}
else
{
m_subsystemAudio.PlayRandomSound("Audio/Creatures/FemaleYellFast", 0.75f, 0f, base.ComponentBody.Position, 2f, autoDelay: false);
}
componentSteedBehavior.SpeedOrder = 1;
m_speedOrderBlocked = true;
}
else if (playerInput.Move.Z < -0.5f && !m_speedOrderBlocked)
{
if (PlayerData.PlayerClass == PlayerClass.Male)
{
m_subsystemAudio.PlayRandomSound("Audio/Creatures/MaleYellSlow", 0.75f, 0f, base.ComponentBody.Position, 2f, autoDelay: false);
}
else
{
m_subsystemAudio.PlayRandomSound("Audio/Creatures/FemaleYellSlow", 0.75f, 0f, base.ComponentBody.Position, 2f, autoDelay: false);
}
componentSteedBehavior.SpeedOrder = -1;
m_speedOrderBlocked = true;
}
else if (MathUtils.Abs(playerInput.Move.Z) <= 0.25f)
{
m_speedOrderBlocked = false;
}
componentSteedBehavior.TurnOrder = playerInput.Move.X;
componentSteedBehavior.JumpOrder = (playerInput.Jump ? 1 : 0);
base.ComponentLocomotion.LookOrder = new Vector2(playerInput.Look.X, 0f);
}
else if (componentBoat != null)
{
componentBoat.TurnOrder = playerInput.Move.X;
componentBoat.MoveOrder = playerInput.Move.Z;
base.ComponentLocomotion.LookOrder = new Vector2(playerInput.Look.X, 0f);
base.ComponentCreatureModel.RowLeftOrder = (playerInput.Move.X <-0.2f || playerInput.Move.Z> 0.2f);
base.ComponentCreatureModel.RowRightOrder = (playerInput.Move.X > 0.2f || playerInput.Move.Z > 0.2f);
}
else
{
base.ComponentLocomotion.WalkOrder = (base.ComponentBody.IsSneaking ? (0.66f * new Vector2(playerInput.SneakMove.X, playerInput.SneakMove.Z)) : new Vector2(playerInput.Move.X, playerInput.Move.Z));
base.ComponentLocomotion.FlyOrder = new Vector3(0f, playerInput.Move.Y, 0f);
base.ComponentLocomotion.TurnOrder = playerInput.Look * new Vector2(1f, 0f);
base.ComponentLocomotion.JumpOrder = MathUtils.Max(playerInput.Jump ? 1 : 0, base.ComponentLocomotion.JumpOrder);
}
base.ComponentLocomotion.LookOrder += playerInput.Look * (SettingsManager.FlipVerticalAxis ? new Vector2(0f, -1f) : new Vector2(0f, 1f));
base.ComponentLocomotion.VrLookOrder = playerInput.VrLook;
base.ComponentLocomotion.VrMoveOrder = playerInput.VrMove;
int num = Terrain.ExtractContents(ComponentMiner.ActiveBlockValue);
Block block = BlocksManager.Blocks[num];
bool flag = false;
if (playerInput.Interact.HasValue && !flag && m_subsystemTime.GameTime - m_lastActionTime > 0.33000001311302185)
{
if (!ComponentMiner.Use(playerInput.Interact.Value))
{
TerrainRaycastResult?terrainRaycastResult = ComponentMiner.Raycast <TerrainRaycastResult>(playerInput.Interact.Value, RaycastMode.Interaction);
if (terrainRaycastResult.HasValue)
{
if (!ComponentMiner.Interact(terrainRaycastResult.Value))
{
if (ComponentMiner.Place(terrainRaycastResult.Value))
{
m_subsystemTerrain.TerrainUpdater.RequestSynchronousUpdate();
flag = true;
m_isAimBlocked = true;
}
}
else
{
m_subsystemTerrain.TerrainUpdater.RequestSynchronousUpdate();
flag = true;
m_isAimBlocked = true;
}
}
}
else
{
m_subsystemTerrain.TerrainUpdater.RequestSynchronousUpdate();
flag = true;
m_isAimBlocked = true;
}
}
float num2 = (m_subsystemGameInfo.WorldSettings.GameMode == GameMode.Creative) ? 0.1f : 1.4f;
if (playerInput.Aim.HasValue && block.IsAimable && m_subsystemTime.GameTime - m_lastActionTime > (double)num2)
{
if (!m_isAimBlocked)
{
Ray3 value = playerInput.Aim.Value;
Vector3 vector = GameWidget.ActiveCamera.WorldToScreen(value.Position + value.Direction, Matrix.Identity);
Point2 size = Window.Size;
if (ComponentInput.IsControlledByVr || (vector.X >= (float)size.X * 0.02f && vector.X < (float)size.X * 0.98f && vector.Y >= (float)size.Y * 0.02f && vector.Y < (float)size.Y * 0.98f))
{
m_aim = value;
if (ComponentMiner.Aim(value, AimState.InProgress))
{
ComponentMiner.Aim(m_aim.Value, AimState.Cancelled);
m_aim = null;
m_isAimBlocked = true;
}
else if (!m_aimHintIssued && Time.PeriodicEvent(1.0, 0.0))
{
Time.QueueTimeDelayedExecution(Time.RealTime + 3.0, delegate
{
if (!m_aimHintIssued && m_aim.HasValue && !base.ComponentBody.IsSneaking)
{
m_aimHintIssued = true;
ComponentGui.DisplaySmallMessage(LanguageControl.Get(fName, 1), Color.White, blinking: true, playNotificationSound: true);
}
});
}
}
else if (m_aim.HasValue)
{
ComponentMiner.Aim(m_aim.Value, AimState.Cancelled);
m_aim = null;
m_isAimBlocked = true;
}
}
}
else
{
m_isAimBlocked = false;
if (m_aim.HasValue)
{
ComponentMiner.Aim(m_aim.Value, AimState.Completed);
m_aim = null;
m_lastActionTime = m_subsystemTime.GameTime;
}
}
flag |= m_aim.HasValue;
if (playerInput.Hit.HasValue && !flag && m_subsystemTime.GameTime - m_lastActionTime > 0.33000001311302185)
{
BodyRaycastResult?bodyRaycastResult = ComponentMiner.Raycast <BodyRaycastResult>(playerInput.Hit.Value, RaycastMode.Interaction);
if (bodyRaycastResult.HasValue)
{
flag = true;
m_isDigBlocked = true;
if (Vector3.Distance(bodyRaycastResult.Value.HitPoint(), base.ComponentCreatureModel.EyePosition) <= 2f)
{
ComponentMiner.Hit(bodyRaycastResult.Value.ComponentBody, bodyRaycastResult.Value.HitPoint(), playerInput.Hit.Value.Direction);
}
}
}
if (playerInput.Dig.HasValue && !flag && !m_isDigBlocked && m_subsystemTime.GameTime - m_lastActionTime > 0.33000001311302185)
{
TerrainRaycastResult?terrainRaycastResult2 = ComponentMiner.Raycast <TerrainRaycastResult>(playerInput.Dig.Value, RaycastMode.Digging);
if (terrainRaycastResult2.HasValue && ComponentMiner.Dig(terrainRaycastResult2.Value))
{
m_lastActionTime = m_subsystemTime.GameTime;
m_subsystemTerrain.TerrainUpdater.RequestSynchronousUpdate();
}
}
if (!playerInput.Dig.HasValue)
{
m_isDigBlocked = false;
}
if (playerInput.Drop && ComponentMiner.Inventory != null)
{
IInventory inventory = ComponentMiner.Inventory;
int slotValue = inventory.GetSlotValue(inventory.ActiveSlotIndex);
int num3 = inventory.RemoveSlotItems(count: inventory.GetSlotCount(inventory.ActiveSlotIndex), slotIndex: inventory.ActiveSlotIndex);
if (slotValue != 0 && num3 != 0)
{
Vector3 position = base.ComponentBody.Position + new Vector3(0f, base.ComponentBody.BoxSize.Y * 0.66f, 0f) + 0.25f * base.ComponentBody.Matrix.Forward;
Vector3 value2 = 8f * Matrix.CreateFromQuaternion(base.ComponentCreatureModel.EyeRotation).Forward;
m_subsystemPickables.AddPickable(slotValue, num3, position, value2, null);
}
}
if (!playerInput.PickBlockType.HasValue || flag)
{
return;
}
ComponentCreativeInventory componentCreativeInventory = ComponentMiner.Inventory as ComponentCreativeInventory;
if (componentCreativeInventory == null)
{
return;
}
TerrainRaycastResult?terrainRaycastResult3 = ComponentMiner.Raycast <TerrainRaycastResult>(playerInput.PickBlockType.Value, RaycastMode.Digging, raycastTerrain: true, raycastBodies: false, raycastMovingBlocks: false);
if (!terrainRaycastResult3.HasValue)
{
return;
}
int value3 = terrainRaycastResult3.Value.Value;
value3 = Terrain.ReplaceLight(value3, 0);
int num4 = Terrain.ExtractContents(value3);
Block block2 = BlocksManager.Blocks[num4];
int num5 = 0;
IEnumerable <int> creativeValues = block2.GetCreativeValues();
if (block2.GetCreativeValues().Contains(value3))
{
num5 = value3;
}
if (num5 == 0 && !block2.IsNonDuplicable)
{
List <BlockDropValue> list = new List <BlockDropValue>();
block2.GetDropValues(m_subsystemTerrain, value3, 0, int.MaxValue, list, out bool _);
if (list.Count > 0 && list[0].Count > 0)
{
num5 = list[0].Value;
}
}
if (num5 == 0)
{
num5 = creativeValues.FirstOrDefault();
}
if (num5 == 0)
{
return;
}
int num6 = -1;
for (int i = 0; i < 10; i++)
{
if (componentCreativeInventory.GetSlotCapacity(i, num5) > 0 && componentCreativeInventory.GetSlotCount(i) > 0 && componentCreativeInventory.GetSlotValue(i) == num5)
{
num6 = i;
break;
}
}
if (num6 < 0)
{
for (int j = 0; j < 10; j++)
{
if (componentCreativeInventory.GetSlotCapacity(j, num5) > 0 && (componentCreativeInventory.GetSlotCount(j) == 0 || componentCreativeInventory.GetSlotValue(j) == 0))
{
num6 = j;
break;
}
}
}
if (num6 < 0)
{
num6 = componentCreativeInventory.ActiveSlotIndex;
}
componentCreativeInventory.RemoveSlotItems(num6, int.MaxValue);
componentCreativeInventory.AddSlotItems(num6, num5, 1);
componentCreativeInventory.ActiveSlotIndex = num6;
ComponentGui.DisplaySmallMessage(block2.GetDisplayName(m_subsystemTerrain, value3), Color.White, blinking: false, playNotificationSound: false);
m_subsystemAudio.PlaySound("Audio/UI/ButtonClick", 1f, 0f, 0f, 0f);
}