public static void Sphere(bool s, int r, int id, TerrainRaycastResult?Point1, SubsystemTerrain subsystemTerrain)
{
Task.Run(() =>
{
int num = 0;
for (int index1 = -r; index1 <= 0; ++index1)
{
for (int index2 = -r; index2 <= 0; ++index2)
{
for (int index3 = -r; index3 <= 0; ++index3)
{
if ((int)Math.Sqrt(index1 * index1 + index2 * index2 + index3 * index3) <= r && (!s || (int)Math.Sqrt((double)((index1 - 1) * (index1 - 1) + index2 * index2 + index3 * index3)) > r || ((int)Math.Sqrt((double)(index1 * index1 + (index2 - 1) * (index2 - 1) + index3 * index3)) > r || (int)Math.Sqrt((double)(index1 * index1 + index2 * index2 + (index3 - 1) * (index3 - 1))) > r)))
{
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index1, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z + index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X - index1, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z + index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X - index1, Point1.Value.CellFace.Point.Y - index2, Point1.Value.CellFace.Point.Z + index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X - index1, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z - index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X - index1, Point1.Value.CellFace.Point.Y - index2, Point1.Value.CellFace.Point.Z - index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index1, Point1.Value.CellFace.Point.Y - index2, Point1.Value.CellFace.Point.Z + index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index1, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z - index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index1, Point1.Value.CellFace.Point.Y - index2, Point1.Value.CellFace.Point.Z - index3, id, true);
num += 8;
}
}
}
}
//this.player.ComponentGui.DisplaySmallMessage(string.Format("操作成功，共生成{0}个方块", (object)num), true, true);
});
}
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 override bool OnUse(Ray3 ray, ComponentMiner componentMiner)
{
_ = componentMiner.Inventory;
if (Terrain.ExtractContents(componentMiner.ActiveBlockValue) == 178)
{
TerrainRaycastResult?terrainRaycastResult = componentMiner.Raycast <TerrainRaycastResult>(ray, RaycastMode.Digging);
if (terrainRaycastResult.HasValue)
{
Vector3 position = terrainRaycastResult.Value.HitPoint();
DynamicArray <ComponentBody> dynamicArray = new DynamicArray <ComponentBody>();
m_subsystemBodies.FindBodiesInArea(new Vector2(position.X, position.Z) - new Vector2(8f), new Vector2(position.X, position.Z) + new Vector2(8f), dynamicArray);
if (dynamicArray.Count((ComponentBody b) => b.Entity.ValuesDictionary.DatabaseObject.Name == "Boat") < 6)
{
Entity entity = DatabaseManager.CreateEntity(base.Project, "Boat", throwIfNotFound: true);
entity.FindComponent <ComponentFrame>(throwOnError: true).Position = position;
entity.FindComponent <ComponentFrame>(throwOnError: true).Rotation = Quaternion.CreateFromAxisAngle(Vector3.UnitY, m_random.Float(0f, (float)Math.PI * 2f));
entity.FindComponent <ComponentSpawn>(throwOnError: true).SpawnDuration = 0f;
base.Project.AddEntity(entity);
componentMiner.RemoveActiveTool(1);
m_subsystemAudio.PlaySound("Audio/BlockPlaced", 1f, 0f, position, 3f, autoDelay: true);
}
else
{
componentMiner.ComponentPlayer?.ComponentGui.DisplaySmallMessage(LanguageControl.Get(fName, 1), Color.White, blinking: true, playNotificationSound: false);
}
return(true);
}
}
return(false);
}
public Vector3 FindBestCameraPosition(Vector3 targetPosition, float distance)
{
Vector3?vector = null;
for (int i = 0; i < 36; i++)
{
float x = 1f + (float)Math.PI * 2f * (float)i / 36f;
Vector3 v2 = Vector3.Normalize(new Vector3(MathUtils.Sin(x), 0.5f, MathUtils.Cos(x)));
Vector3 vector2 = targetPosition + v2 * distance;
TerrainRaycastResult?terrainRaycastResult = base.GameWidget.SubsystemGameWidgets.SubsystemTerrain.Raycast(targetPosition, vector2, useInteractionBoxes: false, skipAirBlocks: true, (int v, float d) => !BlocksManager.Blocks[Terrain.ExtractContents(v)].IsTransparent);
Vector3 zero = Vector3.Zero;
if (terrainRaycastResult.HasValue)
{
CellFace cellFace = terrainRaycastResult.Value.CellFace;
zero = new Vector3((float)cellFace.X + 0.5f, (float)cellFace.Y + 0.5f, (float)cellFace.Z + 0.5f) - 1f * v2;
}
else
{
zero = vector2;
}
if (!vector.HasValue || Vector3.Distance(zero, targetPosition) > Vector3.Distance(vector.Value, targetPosition))
{
vector = zero;
}
}
if (vector.HasValue)
{
return(vector.Value);
}
return(targetPosition);
}
public Sphere(ComponentPlayer player, int id, TerrainRaycastResult?Point1, SubsystemTerrain subsystemTerrain)
{
Point = null;
Point = Point1;
m_subsystemTerrain = subsystemTerrain;
id1 = id;
this.player = player;
WidgetsManager.LoadWidgetContents(this, this, ContentManager.Get <XElement>("WE/DialogsWE/SphereDialog"));
m_title = this.Children.Find <LabelWidget>("Sphere_Dialog.Title", true);
Mode = this.Children.Find <LabelWidget>("Sphere_Dialog.Mode", true);
Icon_select = this.Children.Find <ButtonWidget>("Sphere_Dialog.Icon_select", true);
m_radius = this.Children.Find <SliderWidget>("Sphere_Dialog.Slider1", true);
plusButton = this.Children.Find <ButtonWidget>("Sphere_Dialog.Button4", true);
minusButton = this.Children.Find <ButtonWidget>("Sphere_Dialog.Button3", true);
mSelect_mode = this.Children.Find <ButtonWidget>("Sphere_Dialog.Select_mode", true);
m_okButton = this.Children.Find <ButtonWidget>("Sphere_Dialog.OK", true);
m_cancelButton = this.Children.Find <ButtonWidget>("Sphere_Dialog.Cancel", true);
this.m_blockIconWidget = this.Children.Find <BlockIconWidget>("Sphere_Dialog.Icon", true);
m_title.Text = "Sphere";
//switch_mode.Text = "Holow";
//m_blockIconWidget.Value
Mode.Text = "Hollow";
m_radius.MinValue = 1f;
m_radius.MaxValue = 100;
m_radius.Value = 1f;
names.Add("Soild");
names.Add("Hollow");
foreach (string category in names)
{
m_categories.Add(new Category()
{
Name = category,
});
}
}
public override bool OnUse(Vector3 start, Vector3 direction, ComponentMiner componentMiner)
{
component = componentMiner.ComponentPlayer;
int id = Terrain.ExtractContents(componentMiner.ActiveBlockValue);
TerrainRaycastResult?raycastResult = componentMiner.PickTerrainForDigging(start, direction);
int data = Terrain.ExtractData(componentMiner.ActiveBlockValue);
switch (data)
{
case 0:
componentMiner.ComponentPlayer.ComponentGui.DisplaySmallMessage("a", false, false);
if (raycastResult.HasValue) //桶的使用
{
Point3 point = raycastResult.Value.CellFace.Point;
SubsystemTerrain.Terrain.SetCellValueFast(point.X, point.Y + 2, point.Z, Terrain.MakeBlockValue(1009, 0, 0));
}
break;
case 1:
if (raycastResult.HasValue)
{
Point3 point = raycastResult.Value.CellFace.Point;
SubsystemTerrain.Terrain.SetCellValueFast(point.X, point.Y + 2, point.Z, Terrain.MakeBlockValue(1009, 0, 1));
}
break;
default:
break;
}
return(false);
}
public override bool OnUse(Ray3 ray, ComponentMiner componentMiner)
{
TerrainRaycastResult?terrainRaycastResult = componentMiner.Raycast <TerrainRaycastResult>(ray, RaycastMode.Interaction);
if (terrainRaycastResult.HasValue && terrainRaycastResult.Value.CellFace.Face == 4)
{
int y = terrainRaycastResult.Value.CellFace.Y;
for (int i = terrainRaycastResult.Value.CellFace.X - 1; i <= terrainRaycastResult.Value.CellFace.X + 1; i++)
{
for (int j = terrainRaycastResult.Value.CellFace.Z - 1; j <= terrainRaycastResult.Value.CellFace.Z + 1; j++)
{
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(i, y, j);
if (Terrain.ExtractContents(cellValue) == 168)
{
int data = SoilBlock.SetNitrogen(Terrain.ExtractData(cellValue), 3);
int value = Terrain.ReplaceData(cellValue, data);
m_subsystemTerrain.ChangeCell(i, y, j, value);
}
}
}
m_subsystemAudio.PlayRandomSound("Audio/Impacts/Dirt", 0.5f, 0f, new Vector3(terrainRaycastResult.Value.CellFace.X, terrainRaycastResult.Value.CellFace.Y, terrainRaycastResult.Value.CellFace.Z), 3f, autoDelay: true);
Vector3 position = new Vector3((float)terrainRaycastResult.Value.CellFace.X + 0.5f, (float)terrainRaycastResult.Value.CellFace.Y + 1.5f, (float)terrainRaycastResult.Value.CellFace.Z + 0.5f);
Block block = BlocksManager.Blocks[Terrain.ExtractContents(componentMiner.ActiveBlockValue)];
m_subsystemParticles.AddParticleSystem(block.CreateDebrisParticleSystem(m_subsystemTerrain, position, componentMiner.ActiveBlockValue, 1.25f));
componentMiner.RemoveActiveTool(1);
return(true);
}
return(false);
}
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 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 override bool OnUse(Ray3 ray, ComponentMiner componentMiner)
{
TerrainRaycastResult?terrainRaycastResult = componentMiner.Raycast <TerrainRaycastResult>(ray, RaycastMode.Digging);
if (terrainRaycastResult.HasValue)
{
m_subsystemFurnitureBlockBehavior.ScanDesign(terrainRaycastResult.Value.CellFace, ray.Direction, componentMiner);
return(true);
}
return(false);
}
public Mountain(ComponentPlayer player, TerrainRaycastResult?Point1, SubsystemTerrain subsystemTerrain)
{
m_subsystemTerrain = subsystemTerrain;
Point = Point1;
id1 = 3;
id2 = 2;
id3 = 8;
this.player = player;
WidgetsManager.LoadWidgetContents(this, this, ContentManager.Get <XElement>("WE/DialogsWE/MountainDialog"));
m_title = this.Children.Find <LabelWidget>("Mountain_Dialog.Title", true);
Icon_select = this.Children.Find <ButtonWidget>("Mountain_Dialog.Icon_select", true);
Icon_select1 = this.Children.Find <ButtonWidget>("Mountain_Dialog.Icon_select1", true);
Icon_select2 = this.Children.Find <ButtonWidget>("Mountain_Dialog.Icon_select2", true);
m_radius = this.Children.Find <SliderWidget>("Mountain_Dialog.Slider1", true);
m_lenght = this.Children.Find <SliderWidget>("Mountain_Dialog.Slider2", true);
plusButton = this.Children.Find <ButtonWidget>("Mountain_Dialog.Button4", true);
minusButton = this.Children.Find <ButtonWidget>("Mountain_Dialog.Button3", true);
lenght_plusButton = this.Children.Find <ButtonWidget>("Mountain_Dialog.Button2", true);
lenght_minusButton = this.Children.Find <ButtonWidget>("Mountain_Dialog.Button1", true);
m_okButton = this.Children.Find <ButtonWidget>("Mountain_Dialog.OK", true);
m_cancelButton = this.Children.Find <ButtonWidget>("Mountain_Dialog.Cancel", true);
m_blockIconWidget = this.Children.Find <BlockIconWidget>("Mountain_Dialog.Icon", true);
m_blockIconWidget1 = this.Children.Find <BlockIconWidget>("Mountain_Dialog.Icon1", true);
m_blockIconWidget2 = this.Children.Find <BlockIconWidget>("Mountain_Dialog.Icon2", true);
m_title.Text = "Mountain";
//switch_mode.Text = "Holow";
//m_blockIconWidget.Value
m_radius.MinValue = 1f;
m_radius.MaxValue = 100;
m_radius.Value = 1f;
m_lenght.MinValue = 1f;
m_lenght.MaxValue = 100;
m_lenght.Value = 1f;
}
public override void Update(float dt)
{
ComponentPlayer componentPlayer = base.GameWidget.PlayerData.ComponentPlayer;
if (componentPlayer == null || base.GameWidget.Target == null)
{
return;
}
ComponentInput componentInput = componentPlayer.ComponentInput;
Vector3 cameraSneakMove = componentInput.PlayerInput.CameraSneakMove;
Vector2 cameraLook = componentInput.PlayerInput.CameraLook;
m_angles.X = MathUtils.NormalizeAngle(m_angles.X + 4f * cameraLook.X * dt + 0.5f * cameraSneakMove.X * dt);
m_angles.Y = MathUtils.Clamp(MathUtils.NormalizeAngle(m_angles.Y + 4f * cameraLook.Y * dt), MathUtils.DegToRad(-20f), MathUtils.DegToRad(70f));
m_distance = MathUtils.Clamp(m_distance - 10f * cameraSneakMove.Z * dt, 2f, 16f);
Vector3 v = Vector3.Transform(new Vector3(m_distance, 0f, 0f), Matrix.CreateFromYawPitchRoll(m_angles.X, 0f, m_angles.Y));
Vector3 vector = base.GameWidget.Target.ComponentBody.BoundingBox.Center();
Vector3 vector2 = vector + v;
if (Vector3.Distance(vector2, m_position) < 10f)
{
Vector3 v2 = vector2 - m_position;
float s = MathUtils.Saturate(10f * dt);
m_position += s * v2;
}
else
{
m_position = vector2;
}
Vector3 vector3 = m_position - vector;
float? num = null;
Vector3 vector4 = Vector3.Normalize(Vector3.Cross(vector3, Vector3.UnitY));
Vector3 v3 = Vector3.Normalize(Vector3.Cross(vector3, vector4));
for (int i = 0; i <= 0; i++)
{
for (int j = 0; j <= 0; j++)
{
Vector3 v4 = 0.5f * (vector4 * i + v3 * j);
Vector3 vector5 = vector + v4;
Vector3 end = vector5 + vector3 + Vector3.Normalize(vector3) * 0.5f;
TerrainRaycastResult?terrainRaycastResult = base.GameWidget.SubsystemGameWidgets.SubsystemTerrain.Raycast(vector5, end, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => !BlocksManager.Blocks[Terrain.ExtractContents(value)].IsTransparent);
if (terrainRaycastResult.HasValue)
{
num = (num.HasValue ? MathUtils.Min(num.Value, terrainRaycastResult.Value.Distance) : terrainRaycastResult.Value.Distance);
}
}
}
Vector3 vector6 = (!num.HasValue) ? (vector + vector3) : (vector + Vector3.Normalize(vector3) * MathUtils.Max(num.Value - 0.5f, 0.2f));
SetupPerspectiveCamera(vector6, vector - vector6, Vector3.UnitY);
}
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 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 override void Update(float dt)
{
if (base.GameWidget.Target == null)
{
return;
}
Matrix matrix = Matrix.CreateFromQuaternion(base.GameWidget.Target.ComponentCreatureModel.EyeRotation);
matrix.Translation = base.GameWidget.Target.ComponentBody.Position + 0.5f * base.GameWidget.Target.ComponentBody.BoxSize.Y * Vector3.UnitY;
Vector3 v = -2.25f * matrix.Forward + 1.75f * matrix.Up;
Vector3 vector = matrix.Translation + v;
if (Vector3.Distance(vector, m_position) < 10f)
{
Vector3 v2 = vector - m_position;
float s = 3f * dt;
m_position += s * v2;
}
else
{
m_position = vector;
}
Vector3 vector2 = m_position - matrix.Translation;
float? num = null;
Vector3 vector3 = Vector3.Normalize(Vector3.Cross(vector2, Vector3.UnitY));
Vector3 v3 = Vector3.Normalize(Vector3.Cross(vector2, vector3));
for (int i = 0; i <= 0; i++)
{
for (int j = 0; j <= 0; j++)
{
Vector3 v4 = 0.5f * (vector3 * i + v3 * j);
Vector3 vector4 = matrix.Translation + v4;
Vector3 end = vector4 + vector2 + Vector3.Normalize(vector2) * 0.5f;
TerrainRaycastResult?terrainRaycastResult = base.GameWidget.SubsystemGameWidgets.SubsystemTerrain.Raycast(vector4, end, useInteractionBoxes: false, skipAirBlocks: true, (int value, float distance) => !BlocksManager.Blocks[Terrain.ExtractContents(value)].IsTransparent);
if (terrainRaycastResult.HasValue)
{
num = (num.HasValue ? MathUtils.Min(num.Value, terrainRaycastResult.Value.Distance) : terrainRaycastResult.Value.Distance);
}
}
}
Vector3 vector5 = (!num.HasValue) ? (matrix.Translation + vector2) : (matrix.Translation + Vector3.Normalize(vector2) * MathUtils.Max(num.Value - 0.5f, 0.2f));
SetupPerspectiveCamera(vector5, matrix.Translation - vector5, Vector3.UnitY);
}
public override bool OnUse(Vector3 start, Vector3 direction, ComponentMiner componentMiner)
{
TerrainRaycastResult?terrainRaycastResult = componentMiner.PickTerrainForDigging(start, direction);
ComponentPlayer Player = componentMiner.ComponentPlayer;
if (terrainRaycastResult.HasValue)
{
CreatorAPI creatorAPI;
if (!dictionaryPlayers.TryGetValue(Player, out creatorAPI))
{
listPlayer.Add(Player);
creatorAPI = new CreatorAPI(componentMiner);
dictionaryPlayers.Add(Player, creatorAPI);
}
creatorAPI.OnUse((TerrainRaycastResult)terrainRaycastResult);
}
return(base.OnUse(start, direction, componentMiner));
}
public static void Round(bool s, int radius, int lenght, int pos, int id, TerrainRaycastResult?Point1, SubsystemTerrain subsystemTerrain, ComponentPlayer player)
{
Task.Run(() =>
{
string s2 = Convert.ToString(pos);
//int num1 = 0;
for (int index1 = 0; index1 < lenght; ++index1)
{
for (int index2 = -radius; index2 <= 0; ++index2)
{
for (int index3 = -radius; index3 <= 0; ++index3)
{
if ((int)Math.Sqrt((double)(index2 * index2 + index3 * index3)) <= radius && (!s || (int)Math.Sqrt((double)((index2 - 1) * (index2 - 1) + index3 * index3)) > radius || (int)Math.Sqrt((double)(index2 * index2 + (index3 - 1) * (index3 - 1))) > radius))
{
int num2 = !true ? -index1 : index1;
if (pos == 2)
{
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + num2, Point1.Value.CellFace.Point.Y - index2, Point1.Value.CellFace.Point.Z - index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + num2, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z - index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + num2, Point1.Value.CellFace.Point.Y - index2, Point1.Value.CellFace.Point.Z + index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + num2, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z + index3, id, true);
}
if (pos == 1)
{
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index2, Point1.Value.CellFace.Point.Y + num2, Point1.Value.CellFace.Point.Z + index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index2, Point1.Value.CellFace.Point.Y + num2, Point1.Value.CellFace.Point.Z - index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X - index2, Point1.Value.CellFace.Point.Y + num2, Point1.Value.CellFace.Point.Z + index3, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X - index2, Point1.Value.CellFace.Point.Y + num2, Point1.Value.CellFace.Point.Z - index3, id, true);
}
if (pos == 3)
{
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index2, Point1.Value.CellFace.Point.Y - index3, Point1.Value.CellFace.Point.Z + num2, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index2, Point1.Value.CellFace.Point.Y + index3, Point1.Value.CellFace.Point.Z + num2, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X - index2, Point1.Value.CellFace.Point.Y + index3, Point1.Value.CellFace.Point.Z + num2, id, true);
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X - index2, Point1.Value.CellFace.Point.Y - index3, Point1.Value.CellFace.Point.Z + num2, id, true);
}
// num1 += 4;
}
}
}
}
});
}
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 void Update(float dt)
{
ComponentPlayer componentPlayer = (m_subsystemPlayers.ComponentPlayers.Count > 0) ? m_subsystemPlayers.ComponentPlayers[0] : null;
if (componentPlayer == null)
{
return;
}
if (m_newYearCelebrationTimeRemaining <= 0f && Time.PeriodicEvent(5.0, 0.0) && m_subsystemSky.SkyLightIntensity == 0f && !componentPlayer.ComponentSleep.IsSleeping)
{
DateTime now = DateTime.Now;
if (now.Year > SettingsManager.NewYearCelebrationLastYear && now.Month == 1 && now.Day == 1 && now.Hour == 0 && now.Minute < 59)
{
SettingsManager.NewYearCelebrationLastYear = now.Year;
m_newYearCelebrationTimeRemaining = 180f;
componentPlayer.ComponentGui.DisplayLargeMessage("Happy New Year!", "--- Enjoy the fireworks ---", 15f, 3f);
}
}
if (!(m_newYearCelebrationTimeRemaining > 0f))
{
return;
}
m_newYearCelebrationTimeRemaining -= dt;
float num = (m_newYearCelebrationTimeRemaining > 10f) ? MathUtils.Lerp(1f, 7f, 0.5f * MathUtils.Sin(0.25f * m_newYearCelebrationTimeRemaining) + 0.5f) : 20f;
if (m_random.Float(0f, 1f) < num * dt)
{
Vector2 vector = m_random.Vector2(35f, 50f);
Vector3 vector2 = componentPlayer.ComponentBody.Position + new Vector3(vector.X, 0f, vector.Y);
TerrainRaycastResult?terrainRaycastResult = m_subsystemTerrain.Raycast(new Vector3(vector2.X, 120f, vector2.Z), new Vector3(vector2.X, 40f, vector2.Z), useInteractionBoxes: false, skipAirBlocks: true, null);
if (terrainRaycastResult.HasValue)
{
int data = 0;
data = FireworksBlock.SetShape(data, (FireworksBlock.Shape)m_random.Int(0, 7));
data = FireworksBlock.SetColor(data, m_random.Int(0, 7));
data = FireworksBlock.SetAltitude(data, m_random.Int(0, 1));
data = FireworksBlock.SetFlickering(data, m_random.Float(0f, 1f) < 0.25f);
int value = Terrain.MakeBlockValue(215, 0, data);
Vector3 position = new Vector3(terrainRaycastResult.Value.CellFace.Point.X, terrainRaycastResult.Value.CellFace.Point.Y + 1, terrainRaycastResult.Value.CellFace.Point.Z);
m_subsystemProjectiles.FireProjectile(value, position, new Vector3(m_random.Float(-3f, 3f), 45f, m_random.Float(-3f, 3f)), Vector3.Zero, null);
}
}
}
public static void Prism(bool s, int r, int blockID, TerrainRaycastResult?Point1, SubsystemTerrain subsystemTerrain)
{
int num = 0;
for (int index1 = -r; index1 <= r; ++index1)
{
for (int index2 = -r; index2 <= r; ++index2)
{
for (int index3 = -r; index3 <= r; ++index3)
{
if (Math.Abs(index1) + Math.Abs(index2) + Math.Abs(index3) <= r && (!s || Math.Abs(index1) + Math.Abs(index2) + Math.Abs(index3) >= r))
{
subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index1, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z + index3, blockID);
++num;
}
}
}
}
// m_componentPlayer.ComponentGui.DisplaySmallMessage(string.Format("8989789797", (object)num), true, true);
}
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 ImageDialog(ComponentPlayer player, TerrainRaycastResult?Point1, TerrainRaycastResult?Point2, TerrainRaycastResult?Point3, SubsystemTerrain subsystemTerrain)
{
this.player = player;
this.Point1 = Point1;
this.Point2 = Point2;
this.Point3 = Point3;
this.subsystemTerrain = subsystemTerrain;
WidgetsManager.LoadWidgetContents(this, this, ContentManager.Get <XElement>("WE/DialogsWE/ZoneWidget"));
list_build = Children.Find <ListPanelWidget>("ListView", true);
AddButton = this.Children.Find <ButtonWidget>("AddButton", true);
MoreButton = this.Children.Find <ButtonWidget>("MoreButton", true);
Cancel = this.Children.Find <ButtonWidget>("Cancel", true);
Title = this.Children.Find <LabelWidget>("Dialog.Title", true);
Title.Text = "Image in SC";
names_item.Add("Delete");
//names_item.Add("Rename");
names_item.Add("Create");
foreach (string category in names_item)
{
m_categories.Add(new Category()
{
Name = category,
});
}
MoreButton.IsEnabled = false;
update_builds();
}
public override bool OnUse(Ray3 ray, ComponentMiner componentMiner)
{
TerrainRaycastResult?terrainRaycastResult = componentMiner.Raycast <TerrainRaycastResult>(ray, RaycastMode.Interaction);
if (terrainRaycastResult.HasValue)
{
if (terrainRaycastResult.Value.CellFace.Face == 4)
{
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(terrainRaycastResult.Value.CellFace.X, terrainRaycastResult.Value.CellFace.Y, terrainRaycastResult.Value.CellFace.Z);
int num = Terrain.ExtractContents(cellValue);
Block block = BlocksManager.Blocks[num];
switch (num)
{
case 2:
{
int value2 = Terrain.ReplaceContents(cellValue, 168);
m_subsystemTerrain.ChangeCell(terrainRaycastResult.Value.CellFace.X, terrainRaycastResult.Value.CellFace.Y, terrainRaycastResult.Value.CellFace.Z, value2);
m_subsystemAudio.PlayRandomSound("Audio/Impacts/Dirt", 0.5f, 0f, new Vector3(terrainRaycastResult.Value.CellFace.X, terrainRaycastResult.Value.CellFace.Y, terrainRaycastResult.Value.CellFace.Z), 3f, autoDelay: true);
Vector3 position2 = new Vector3((float)terrainRaycastResult.Value.CellFace.X + 0.5f, (float)terrainRaycastResult.Value.CellFace.Y + 1.25f, (float)terrainRaycastResult.Value.CellFace.Z + 0.5f);
m_subsystemParticles.AddParticleSystem(block.CreateDebrisParticleSystem(m_subsystemTerrain, position2, cellValue, 0.5f));
break;
}
case 8:
{
int value = Terrain.ReplaceContents(cellValue, 2);
m_subsystemTerrain.ChangeCell(terrainRaycastResult.Value.CellFace.X, terrainRaycastResult.Value.CellFace.Y, terrainRaycastResult.Value.CellFace.Z, value);
m_subsystemAudio.PlayRandomSound("Audio/Impacts/Plant", 0.5f, 0f, new Vector3(terrainRaycastResult.Value.CellFace.X, terrainRaycastResult.Value.CellFace.Y, terrainRaycastResult.Value.CellFace.Z), 3f, autoDelay: true);
Vector3 position = new Vector3((float)terrainRaycastResult.Value.CellFace.X + 0.5f, (float)terrainRaycastResult.Value.CellFace.Y + 1.2f, (float)terrainRaycastResult.Value.CellFace.Z + 0.5f);
m_subsystemParticles.AddParticleSystem(block.CreateDebrisParticleSystem(m_subsystemTerrain, position, cellValue, 0.75f));
break;
}
}
}
componentMiner.DamageActiveTool(1);
return(true);
}
return(false);
}
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 void lingTi(bool s, int f, int blockID, int r, TerrainRaycastResult?Point1)
{
int num = 0;
for (int index1 = -r; index1 <= r; ++index1)
{
for (int index2 = -r; index2 <= r; ++index2)
{
for (int index3 = -r; index3 <= r; ++index3)
{
if (f == 1)
{
if (Math.Abs(index1) + Math.Abs(index2) <= r && Math.Abs(index3) + Math.Abs(index2) <= r && (!s || Math.Abs(index1) + Math.Abs(index2) >= r || Math.Abs(index3) + Math.Abs(index2) >= r))
{
m_subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index1, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z + index3, blockID, true);
++num;
}
}
else if (f == 2)
{
if (Math.Abs(index2) + Math.Abs(index1) <= r && Math.Abs(index3) + Math.Abs(index1) <= r && (!s || Math.Abs(index2) + Math.Abs(index1) >= r || Math.Abs(index3) + Math.Abs(index1) >= r))
{
m_subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index1, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z + index3, blockID, true);
++num;
}
}
else if (Math.Abs(index2) + Math.Abs(index3) <= r && Math.Abs(index1) + Math.Abs(index3) <= r && (!s || Math.Abs(index2) + Math.Abs(index3) >= r || Math.Abs(index1) + Math.Abs(index3) >= r))
{
m_subsystemTerrain.ChangeCell(Point1.Value.CellFace.Point.X + index1, Point1.Value.CellFace.Point.Y + index2, Point1.Value.CellFace.Point.Z + index3, blockID, true);
++num;
}
}
}
}
m_componentPlayer.ComponentGui.DisplaySmallMessage(string.Format("7896868", (object)num), true, true);
}
internal static void WorldEditModApi()
{
if (!(ScreensManager.GetScreenName(ScreensManager.CurrentScreen) == "Game")) // Выходим, если мы не в игре
{
return;
}
// Показазывеем контейнер с кнопками, если активирована кнопка WorldEditMenu
ScreensManager.CurrentScreen.ScreenWidget.FindWidget<StackPanelWidget>("WorldEditMenuContainerTop", true).IsVisible = ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("WorldEditMenu", true).IsChecked;
ScreensManager.CurrentScreen.ScreenWidget.FindWidget<StackPanelWidget>("WorldEditMenuContainerBottom", true).IsVisible = ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("WorldEditMenu", true).IsChecked;
// Смена режима управления
if (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("WorldEditMenu", true).IsTapped)
{
if (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("WorldEditMenu", true).IsChecked)
{
OldLookControlMode = (int) SettingsManager.LookControlMode;
SettingsManager.LookControlMode = LookControlMode.SplitTouch;
}
else
{
SettingsManager.LookControlMode = (LookControlMode) OldLookControlMode;
}
}
if ((Engine.Input.Keyboard.IsKeyDown(Engine.Input.Key.F1)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("F1", true).IsTapped)) // Выделение 1 точки
{
ComponentMiner componentMiner = Subsystems.Player.ComponentPlayer.ComponentMiner;
Point1 = componentMiner.PickTerrainForDigging(Subsystems.Drawing.ViewPosition, Subsystems.Drawing.ViewDirection);
if (Point1.HasValue)
{
SCModApi.Gui.DisplayMessage("Set position 1 on: " + Point1.Value.CellFace.X + ", " + Point1.Value.CellFace.Y + ", " + Point1.Value.CellFace.Z, false);
SelectedBlock = World.GetBlock(Point1.Value.CellFace.X, Point1.Value.CellFace.Y, Point1.Value.CellFace.Z);
return;
}
}
if ((Engine.Input.Keyboard.IsKeyDown(Engine.Input.Key.F2)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("F2", true).IsTapped)) // Выделение 2 точки
{
ComponentMiner componentMiner = Subsystems.Player.ComponentPlayer.ComponentMiner;
Point2 = componentMiner.PickTerrainForDigging(Subsystems.Drawing.ViewPosition, Subsystems.Drawing.ViewDirection);
if (Point2.HasValue)
{
SCModApi.Gui.DisplayMessage("Set position 2 on: " + Point1.Value.CellFace.X + ", " + Point1.Value.CellFace.Y + ", " + Point1.Value.CellFace.Z, false);
ReplaceableBlock = Subsystems.Terrain.TerrainData.GetCellValue(Point2.Value.CellFace.X, Point2.Value.CellFace.Y, Point2.Value.CellFace.Z);
return;
}
}
if ((Engine.Input.Keyboard.IsKeyDown(Engine.Input.Key.F3)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("F3", true).IsTapped)) // Выделение 3 точки
{
ComponentMiner componentMiner = Subsystems.Player.ComponentPlayer.ComponentMiner;
Point3 = componentMiner.PickTerrainForDigging(Subsystems.Drawing.ViewPosition, Subsystems.Drawing.ViewDirection);
if (Point3.HasValue)
{
SCModApi.Gui.DisplayMessage("Set position 3 on: " + Point1.Value.CellFace.X + ", " + Point1.Value.CellFace.Y + ", " + Point1.Value.CellFace.Z, false);
return;
}
}
if (Point1.HasValue && Point2.HasValue && ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("WorldEditMenu", true).IsChecked) // Выделение зоны между точками 1 и 2
{
int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int endX = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int endY = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
int endZ = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
PrimitivesRenderer3D PrimitivesRenderer3D = new PrimitivesRenderer3D();
Vector3 pointStart = new Vector3(startX, startY, startZ);
Vector3 pointEnd = new Vector3(endX + 1, endY + 1, endZ + 1);
BoundingBox boundingBox = new BoundingBox(pointStart, pointEnd);
PrimitivesRenderer3D.FlatBatch(-1, DepthStencilState.None, (RasterizerState)null, (BlendState)null).QueueBoundingBox(boundingBox, Color.Green);
PrimitivesRenderer3D.Flush(Subsystems.Drawing.ViewProjectionMatrix, true);
}
if (Point3.HasValue && ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("WorldEditMenu", true).IsChecked) // Выделение зоны вставки
{
int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int endX = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int endY = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
int endZ = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
startX += Point3.Value.CellFace.Point.X - Point1.Value.CellFace.Point.X;
startY += Point3.Value.CellFace.Point.Y - Point1.Value.CellFace.Point.Y;
startZ += Point3.Value.CellFace.Point.Z - Point1.Value.CellFace.Point.Z;
endX += Point3.Value.CellFace.Point.X - Point1.Value.CellFace.Point.X;
endY += Point3.Value.CellFace.Point.Y - Point1.Value.CellFace.Point.Y;
endZ += Point3.Value.CellFace.Point.Z - Point1.Value.CellFace.Point.Z;
PrimitivesRenderer3D primitivesRenderer3D = new PrimitivesRenderer3D();
Vector3 pointStart = new Vector3(startX, startY, startZ);
Vector3 pointEnd = new Vector3(endX + 1, endY + 1, endZ + 1);
BoundingBox boundingBox = new BoundingBox(pointStart, pointEnd);
primitivesRenderer3D.FlatBatch(-1, DepthStencilState.None, (RasterizerState)null, (BlendState)null).QueueBoundingBox(boundingBox, Color.Red);
primitivesRenderer3D.Flush(Subsystems.Drawing.ViewProjectionMatrix, true);
}
if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F5)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("F5", true).IsTapped)) // Копирование выделенной зоны
{
if (Point1 == null)
{
Gui.DisplayMessage("You have not selected point 1", false);
}
else if (Point2 == null)
{
Gui.DisplayMessage("You have not selected point 2", false);
}
else if (Point3 == null)
{
Gui.DisplayMessage("You have not selected point 3", false);
}
else
{
int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int endX = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int endY = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
int endZ = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
for (int y = 0; y <= endY - startY; y++)
{
for (int z = 0; z <= endZ - startZ; z++)
{
for (int x = 0; x <= endX - startX; x++)
{
int targetX, targetY, targetZ;
int PlaceX, PlaceY, PlaceZ;
if (Point1.Value.CellFace.Point.X > Point2.Value.CellFace.Point.X)
{
targetX = Point1.Value.CellFace.Point.X - x;
PlaceX = Point3.Value.CellFace.Point.X - x;
}
else
{
targetX = Point1.Value.CellFace.Point.X + x;
PlaceX = Point3.Value.CellFace.Point.X + x;
}
if (Point1.Value.CellFace.Point.Y > Point2.Value.CellFace.Point.Y)
{
targetY = Point1.Value.CellFace.Point.Y - y;
PlaceY = Point3.Value.CellFace.Point.Y - y;
}
else
{
targetY = Point1.Value.CellFace.Point.Y + y;
PlaceY = Point3.Value.CellFace.Point.Y + y;
}
if (Point1.Value.CellFace.Point.Z > Point2.Value.CellFace.Point.Z)
{
targetZ = Point1.Value.CellFace.Point.Z - z;
PlaceZ = Point3.Value.CellFace.Point.Z - z;
}
else
{
targetZ = Point1.Value.CellFace.Point.Z + z;
PlaceZ = Point3.Value.CellFace.Point.Z + z;
}
int block = World.GetBlock(targetX, targetY, targetZ);
// 15360 - Air
if (block != 15360) World.SetBlock(PlaceX, PlaceY, PlaceZ, block);
}
}
}
}
return;
}
if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F6)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("F6", true).IsTapped)) // Заполнение зоны
{
if (Point1 == null)
{
Gui.DisplayMessage("You have not selected point 1", false);
}
else if (Point2 == null)
{
Gui.DisplayMessage("You have not selected point 2", false);
}
else
{
int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int endX = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int endY = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
int endZ = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
for (int x = startX; x <= endX; x++)
{
for (int y = startY; y <= endY; y++)
{
for (int z = startZ; z <= endZ; z++)
{
World.SetBlock(x, y, z, SelectedBlock);
}
}
}
}
return;
}
if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F7)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("F7", true).IsTapped)) // Замена зоны
{
if (Point1 == null)
{
Gui.DisplayMessage("You have not selected point 1", false);
}
else if (Point2 == null)
{
Gui.DisplayMessage("You have not selected point 2", false);
}
else
{
int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int endX = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int endY = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
int endZ = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
for (int x = startX; x <= endX; x++)
{
for (int y = startY; y <= endY; y++)
{
for (int z = startZ; z <= endZ; z++)
{
if (World.GetBlock(x, y, z) == ReplaceableBlock) World.SetBlock(x, y, z, SelectedBlock);
}
}
}
}
return;
}
if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F8)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("F8", true).IsTapped)) // Очистка зоны
{
if (Point1 == null)
{
Gui.DisplayMessage("You have not selected point 1", false);
}
else if (Point2 == null)
{
Gui.DisplayMessage("You have not selected point 2", false);
}
else
{
int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int endX = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int endY = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
int endZ = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
for (int x = startX; x <= endX; x++)
{
for (int y = startY; y <= endY; y++)
{
for (int z = startZ; z <= endZ; z++)
{
World.SetBlock(x, y, z, 0);
}
}
}
}
return;
}
if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F9)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("F9", true).IsTapped)) // Копирование зоны в память
{
if (Point1 == null)
{
Gui.DisplayMessage("You have not selected point 1", false);
}
else if (Point2 == null)
{
Gui.DisplayMessage("You have not selected point 2", false);
}
else
{
int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int endX = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int endY = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
int endZ = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
blockCount = 0;
BlockList.Clear();
for (int x = 0; x <= endX - startX; x++)
{
for (int y = 0; y <= endY - startY; y++)
{
for (int z = 0; z <= endZ - startZ; z++)
{
BlockMem blmem = new BlockMem();
int X, Y, Z;
if (Point1.Value.CellFace.Point.X > Point2.Value.CellFace.Point.X)
{
blmem.x = - x;
X = Point1.Value.CellFace.Point.X - x;
}
else
{
blmem.x = x;
X = Point1.Value.CellFace.Point.X + x;
}
if (Point1.Value.CellFace.Point.Y > Point2.Value.CellFace.Point.Y)
{
blmem.y = - y;
Y = Point1.Value.CellFace.Point.Y - y;
}
else
{
blmem.y = y;
Y = Point1.Value.CellFace.Point.Y + y;
}
if (Point1.Value.CellFace.Point.Z > Point2.Value.CellFace.Point.Z)
{
blmem.z = - z;
Z = Point1.Value.CellFace.Point.Z - z;
}
else
{
blmem.z = z;
Z = Point1.Value.CellFace.Point.Z + z;
}
blmem.id = World.GetBlock(X, Y, Z);
BlockList.Add(blmem);
blockCount++;
}
}
}
}
Gui.DisplayMessage("Copied " + blockCount + " blocks", false);
return;
}
if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F10)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget<BitmapButtonWidget>("F10", true).IsTapped)) // Вставка зоны из памяти
{
if (Point3 == null) Gui.DisplayMessage("You have not selected point 3", false);
else
{
for (var i = 0; i < blockCount; i++)
{
var xPos = Point3.Value.CellFace.X + BlockList[i].x;
var yPos = Point3.Value.CellFace.Y + BlockList[i].y;
var zPos = Point3.Value.CellFace.Z + BlockList[i].z;
World.SetBlock(xPos, yPos, zPos, BlockList[i].id);
}
Gui.DisplayMessage("Pasted " + blockCount + " blocks", false);
}
}
}
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 Rectangle(ComponentPlayer player, int id, TerrainRaycastResult?Point1, TerrainRaycastResult?Point2, SubsystemTerrain subsystemTerrain)
{
m_subsystemTerrain = subsystemTerrain;
Point = Point1;
this.Point2 = Point2;
id1 = id;
this.player = player;
WidgetsManager.LoadWidgetContents(this, this, ContentManager.Get <XElement>("WE/DialogsWE/PillarDialog"));
m_title = this.Children.Find <LabelWidget>("Pillar_Dialog.Title", true);
mPosition = this.Children.Find <LabelWidget>("Pillar_Dialog.Pos", true);
Icon_select = this.Children.Find <ButtonWidget>("Pillar_Dialog.Icon_select", true);
mselect_pos = this.Children.Find <ButtonWidget>("Pillar_Dialog.Select_pos", true);
m_okButton = this.Children.Find <ButtonWidget>("Pillar_Dialog.OK", true);
m_cancelButton = this.Children.Find <ButtonWidget>("Pillar_Dialog.Cancel", true);
this.m_blockIconWidget = this.Children.Find <BlockIconWidget>("Pillar_Dialog.Icon", true);
m_title.Text = "Frame or box";
//switch_mode.Text = "Holow";
//m_blockIconWidget.Value
mPosition.Text = "Frame";
m_blockIconWidget.Value = id;
names.Add("Soild");
names.Add("Hollow");
names_pos.Add("Frame");
names_pos.Add("Hollow Box");
names_pos.Add("Soild Box");
foreach (string category in names)
{
m_categories.Add(new Category()
{
Name = category,
});
}
foreach (string category in names_pos)
{
m_categories_pos.Add(new Category()
{
Name = category,
});
}
}
public new void Update(float dt)
{
PlayerInput playerInput = ComponentInput.PlayerInput;
if (ComponentInput.IsControlledByTouch && m_aimDirection.HasValue)
{
playerInput.Look = Vector2.Zero;
}
if (ComponentMiner.Inventory != null)
{
ComponentMiner.Inventory.ActiveSlotIndex = MathUtils.Clamp(ComponentMiner.Inventory.ActiveSlotIndex + playerInput.ScrollInventory, 0, 5);
if (playerInput.SelectInventorySlot.HasValue)
{
ComponentMiner.Inventory.ActiveSlotIndex = MathUtils.Clamp(playerInput.SelectInventorySlot.Value, 0, 5);
}
}
if (m_subsystemTime.PeriodicGameTimeEvent(0.5, 0))
{
ReadOnlyList <int> readOnlyList = ComponentClothing.GetClothes(ClothingSlot.Head);
if ((readOnlyList.Count > 0 && ClothingBlock.GetClothingData(readOnlyList[readOnlyList.Count - 1]).DisplayName == Utils.Get("DZˮͷ¿ø")) || (ComponentBody.ImmersionFluidBlock != null && ComponentBody.ImmersionFluidBlock.BlockIndex == RottenMeatBlock.Index))
{
//if (ComponentBody.ImmersionDepth > 0.8f)
//ComponentScreenOverlays.BlackoutFactor = 1f;
ComponentHealth.Air = 1f;
}
}
ComponentMount mount = ComponentRider.Mount;
if (mount != null)
{
var componentSteedBehavior = mount.Entity.FindComponent <ComponentSteedBehavior>();
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, ComponentBody.Position, 2f, false);
}
else
{
m_subsystemAudio.PlayRandomSound("Audio/Creatures/FemaleYellFast", 0.75f, 0f, ComponentBody.Position, 2f, 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, ComponentBody.Position, 2f, false);
}
else
{
m_subsystemAudio.PlayRandomSound("Audio/Creatures/FemaleYellSlow", 0.75f, 0f, ComponentBody.Position, 2f, 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;
ComponentLocomotion.LookOrder = new Vector2(playerInput.Look.X, 0f);
}
else
{
var componentBoat = mount.Entity.FindComponent <ComponentBoat>();
if (componentBoat != null || mount.Entity.FindComponent <ComponentBoatI>() != null)
{
if (componentBoat != null)
{
componentBoat.TurnOrder = playerInput.Move.X;
componentBoat.MoveOrder = playerInput.Move.Z;
ComponentLocomotion.LookOrder = new Vector2(playerInput.Look.X, 0f);
}
else
{
ComponentLocomotion.LookOrder = playerInput.Look;
}
ComponentCreatureModel.RowLeftOrder = playerInput.Move.X <-0.2f || playerInput.Move.Z> 0.2f;
ComponentCreatureModel.RowRightOrder = playerInput.Move.X > 0.2f || playerInput.Move.Z > 0.2f;
}
var c = mount.Entity.FindComponent <ComponentLocomotion>();
if (c != null)
{
c.WalkOrder = playerInput.Move.XZ;
c.FlyOrder = new Vector3(0f, playerInput.Move.Y, 0f);
c.TurnOrder = playerInput.Look * new Vector2(1f, 0f);
c.JumpOrder = playerInput.Jump ? 1 : 0;
c.LookOrder = playerInput.Look;
if (playerInput.ToggleCreativeFly)
{
c.IsCreativeFlyEnabled = !c.IsCreativeFlyEnabled;
}
}
}
}
else
{
ComponentLocomotion.WalkOrder = (ComponentLocomotion.WalkOrder ?? Vector2.Zero) + (ComponentBody.IsSneaking ? (0.66f * new Vector2(playerInput.SneakMove.X, playerInput.SneakMove.Z)) : new Vector2(playerInput.Move.X, playerInput.Move.Z));
ComponentLocomotion.FlyOrder = new Vector3(0f, playerInput.Move.Y, 0f);
ComponentLocomotion.TurnOrder = playerInput.Look * new Vector2(1f, 0f);
ComponentLocomotion.JumpOrder = MathUtils.Max(playerInput.Jump ? 1 : 0, ComponentLocomotion.JumpOrder);
}
ComponentLocomotion.LookOrder += playerInput.Look * (SettingsManager.FlipVerticalAxis ? new Vector2(0f, -1f) : new Vector2(0f, 1f));
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)
{
Vector3 viewPosition = View.ActiveCamera.ViewPosition;
var direction = Vector3.Normalize(View.ActiveCamera.ScreenToWorld(new Vector3(playerInput.Interact.Value, 1f), Matrix.Identity) - viewPosition);
if (!ComponentMiner.Use(viewPosition, direction))
{
var body = ComponentMiner.PickBody(viewPosition, direction);
var result = ComponentMiner.PickTerrainForInteraction(viewPosition, direction);
if (result.HasValue && (!body.HasValue || result.Value.Distance < body.Value.Distance))
{
if (!ComponentMiner.Interact(result.Value))
{
if (ComponentMiner.Place(result.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 || block.BlockIndex == Musket2Block.Index) ? 0.1f : 1.4f;
Vector3 viewPosition2 = View.ActiveCamera.ViewPosition;
if (playerInput.Aim.HasValue && block.IsAimable && m_subsystemTime.GameTime - m_lastActionTime > num2)
{
if (!m_isAimBlocked)
{
Vector2 value = playerInput.Aim.Value;
Vector3 v = View.ActiveCamera.ScreenToWorld(new Vector3(value, 1f), Matrix.Identity);
Point2 size = Window.Size;
if (playerInput.Aim.Value.X >= size.X * 0.1f && playerInput.Aim.Value.X < size.X * 0.9f && playerInput.Aim.Value.Y >= size.Y * 0.1f && playerInput.Aim.Value.Y < size.Y * 0.9f)
{
m_aimDirection = Vector3.Normalize(v - viewPosition2);
if (ComponentMiner.Aim(viewPosition2, m_aimDirection.Value, AimState.InProgress))
{
ComponentMiner.Aim(viewPosition2, m_aimDirection.Value, AimState.Cancelled);
m_aimDirection = null;
m_isAimBlocked = true;
}
}
else if (m_aimDirection.HasValue)
{
ComponentMiner.Aim(viewPosition2, m_aimDirection.Value, AimState.Cancelled);
m_aimDirection = null;
m_isAimBlocked = true;
}
}
}
else
{
m_isAimBlocked = false;
if (m_aimDirection.HasValue)
{
ComponentMiner.Aim(viewPosition2, m_aimDirection.Value, AimState.Completed);
m_aimDirection = null;
m_lastActionTime = m_subsystemTime.GameTime;
}
}
flag |= m_aimDirection.HasValue;
if (playerInput.Hit.HasValue && !flag && m_subsystemTime.GameTime - m_lastActionTime > 0.33000001311302185)
{
Vector3 viewPosition3 = View.ActiveCamera.ViewPosition;
var vector = Vector3.Normalize(View.ActiveCamera.ScreenToWorld(new Vector3(playerInput.Hit.Value, 1f), Matrix.Identity) - viewPosition3);
TerrainRaycastResult?nullable3 = ComponentMiner.PickTerrainForInteraction(viewPosition3, vector);
BodyRaycastResult? nullable4 = ComponentMiner.PickBody(viewPosition3, vector);
if (nullable4.HasValue && (!nullable3.HasValue || nullable3.Value.Distance > nullable4.Value.Distance))
{
if (ComponentMiner.ActiveBlockValue == 0)
{
Widget widget = ComponentNGui.OpenEntity(ComponentMiner.Inventory, nullable4.Value.ComponentBody.Entity);
if (widget != null)
{
ComponentGui.ModalPanelWidget = widget;
AudioManager.PlaySound("Audio/UI/ButtonClick", 1f, 0f, 0f);
return;
}
}
flag = true;
m_isDigBlocked = true;
if (Vector3.Distance(viewPosition3 + vector * nullable4.Value.Distance, ComponentCreatureModel.EyePosition) <= 2f)
{
ComponentMiner.Hit(nullable4.Value.ComponentBody, vector);
}
}
}
if (playerInput.Dig.HasValue && !flag && !m_isDigBlocked && m_subsystemTime.GameTime - m_lastActionTime > 0.33000001311302185)
{
Vector3 viewPosition4 = View.ActiveCamera.ViewPosition;
Vector3 v2 = View.ActiveCamera.ScreenToWorld(new Vector3(playerInput.Dig.Value, 1f), Matrix.Identity);
TerrainRaycastResult?nullable5 = ComponentMiner.PickTerrainForDigging(viewPosition4, v2 - viewPosition4);
if (nullable5.HasValue && ComponentMiner.Dig(nullable5.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 v3 = ComponentBody.Position + new Vector3(0f, ComponentBody.BoxSize.Y * 0.66f, 0f);
Matrix matrix = ComponentBody.Matrix;
Vector3 position = v3 + 0.25f * matrix.Forward;
matrix = Matrix.CreateFromQuaternion(ComponentCreatureModel.EyeRotation);
Vector3 value2 = 8f * matrix.Forward;
m_subsystemPickables.AddPickable(slotValue, num3, position, value2, null);
}
}
if (playerInput.PickBlockType.HasValue && !flag)
{
if (ComponentMiner.Inventory is ComponentCreativeInventory componentCreativeInventory)
{
Vector3 viewPosition5 = View.ActiveCamera.ViewPosition;
Vector3 v4 = View.ActiveCamera.ScreenToWorld(new Vector3(playerInput.PickBlockType.Value, 1f), Matrix.Identity);
TerrainRaycastResult?nullable6 = ComponentMiner.PickTerrainForDigging(viewPosition5, v4 - viewPosition5);
if (nullable6.HasValue)
{
int value3 = nullable6.Value.Value;
value3 = Terrain.ReplaceLight(value3, 0);
int num4 = Terrain.ExtractContents(value3);
Block block2 = BlocksManager.Blocks[num4];
int num5 = 0;
var creativeValues = block2.GetCreativeValues();
if (block2.GetCreativeValues().Contains(value3))
{
num5 = value3;
}
if (num5 == 0 && !block2.IsNonDuplicable)
{
var list = new List <BlockDropValue>();
bool _;
block2.GetDropValues(m_subsystemTerrain, value3, 0, 2147483647, list, out _);
if (list.Count > 0 && list[0].Count > 0)
{
num5 = list[0].Value;
}
}
if (num5 == 0)
{
num5 = creativeValues.FirstOrDefault();
}
if (num5 != 0)
{
int num6 = -1;
for (int i = 0; i < 6; i++)
{
if (componentCreativeInventory.GetSlotCount(i) > 0 && componentCreativeInventory.GetSlotValue(i) == num5)
{
num6 = i;
break;
}
}
if (num6 < 0)
{
for (int j = 0; j < 6; j++)
{
if (componentCreativeInventory.GetSlotCount(j) == 0 || componentCreativeInventory.GetSlotValue(j) == 0)
{
num6 = j;
break;
}
}
}
if (num6 < 0)
{
num6 = componentCreativeInventory.ActiveSlotIndex;
}
componentCreativeInventory.RemoveSlotItems(num6, 2147483647);
componentCreativeInventory.AddSlotItems(num6, num5, 1);
componentCreativeInventory.ActiveSlotIndex = num6;
ComponentGui.DisplaySmallMessage(block2.GetDisplayName(m_subsystemTerrain, value3), false, false);
m_subsystemAudio.PlaySound("Audio/UI/ButtonClick", 1f, 0f, 0f, 0f);
}
}
}
}
HighlightRaycastResult = ComponentMiner.PickTerrainForDigging(View.ActiveCamera.ViewPosition, View.ActiveCamera.ViewDirection);
}
public void WE()
{
if (!(m_subsystemGameInfo.WorldSettings.GameMode == GameMode.Creative))
{
WorldEditMenu.IsVisible = false;
}
else
{
WorldEditMenu.IsVisible = true;
}
WorldEditMenuContainerBottom.IsVisible = WorldEditMenu.IsChecked;
WorldEditMenuContainerTop.IsVisible = WorldEditMenu.IsChecked;
if (WorldEditMenu.IsClicked)
{
if (WorldEditMenu.IsChecked)
{
OldLookControlMode = (int)SettingsManager.LookControlMode;
SettingsManager.LookControlMode = LookControlMode.SplitTouch;
}
else
{
SettingsManager.LookControlMode = (LookControlMode)OldLookControlMode;
}
}
//Vector3 viewDirection = cam.ViewDirection;
//m_componentPlayer.ComponentBody.Velocity = new Vector3(viewDirection.X * 100f, viewDirection.Y * 100f, viewDirection.Z * 100f);
if (Keyboard.IsKeyDownOnce(Engine.Input.Key.F1) || F1.IsClicked)
{
Point1 = m_componentPlayer.ComponentMiner.PickTerrainForDigging(this.cam.ViewPosition, this.cam.ViewDirection);
if (Point1.HasValue)
{
SelectedBlock = m_subsystemTerrain.Terrain.GetCellValue(Point1.Value.CellFace.X, Point1.Value.CellFace.Y, Point1.Value.CellFace.Z);
m_componentPlayer.ComponentGui.DisplaySmallMessage("Set position 1 on: " + (object)Point1.Value.CellFace.X + ", " + (object)Point1.Value.CellFace.Y + ", " + (object)Point1.Value.CellFace.Z + ",Block ID " + (object)SelectedBlock, false, false);
}
}
if (Keyboard.IsKeyDown(Engine.Input.Key.F2) || F2.IsClicked)
{
Point2 = m_componentPlayer.ComponentMiner.PickTerrainForDigging(this.cam.ViewPosition, this.cam.ViewDirection);
if (Point2.HasValue)
{
ReplaceableBlock = m_subsystemTerrain.Terrain.GetCellValue(Point2.Value.CellFace.X, Point2.Value.CellFace.Y, Point2.Value.CellFace.Z);
m_componentPlayer.ComponentGui.DisplaySmallMessage("Set position 2 on: " + (object)Point2.Value.CellFace.X + ", " + (object)Point2.Value.CellFace.Y + ", " + (object)Point2.Value.CellFace.Z + ",Block ID " + (object)ReplaceableBlock, false, false);
}
}
if (Keyboard.IsKeyDown(Engine.Input.Key.F3) || F3.IsClicked)
{
Point3 = m_componentPlayer.ComponentMiner.PickTerrainForDigging(this.cam.ViewPosition, this.cam.ViewDirection);
if (Point3.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("Set position 3 on: " + (object)Point1.Value.CellFace.X + ", " + (object)Point1.Value.CellFace.Y + ", " + (object)Point1.Value.CellFace.Z, false, false);
return;
}
}
if (Keyboard.IsKeyDownOnce(Engine.Input.Key.F5) || F5.IsClicked)
{
if (!Point1.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("You have not selected point 1", false, false);
}
else if (!Point2.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("You have not selected point 2", false, false);
}
else if (!Point3.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("You have not selected point 3", false, false);
}
else
{
TerrainRaycastResult terrainRaycastResult = Point1.Value;
int x1 = terrainRaycastResult.CellFace.Point.X;
terrainRaycastResult = Point2.Value;
int x2 = terrainRaycastResult.CellFace.Point.X;
int num1 = Math.Min(x1, x2);
terrainRaycastResult = Point1.Value;
int x3 = terrainRaycastResult.CellFace.Point.X;
terrainRaycastResult = Point2.Value;
int x4 = terrainRaycastResult.CellFace.Point.X;
int num2 = Math.Max(x3, x4);
terrainRaycastResult = Point1.Value;
int y1 = terrainRaycastResult.CellFace.Point.Y;
terrainRaycastResult = Point2.Value;
int y2 = terrainRaycastResult.CellFace.Point.Y;
int num3 = Math.Min(y1, y2);
terrainRaycastResult = Point1.Value;
int y3 = terrainRaycastResult.CellFace.Point.Y;
terrainRaycastResult = Point2.Value;
int y4 = terrainRaycastResult.CellFace.Point.Y;
int num4 = Math.Max(y3, y4);
terrainRaycastResult = Point1.Value;
int z1 = terrainRaycastResult.CellFace.Point.Z;
terrainRaycastResult = Point2.Value;
int z2 = terrainRaycastResult.CellFace.Point.Z;
int num5 = Math.Min(z1, z2);
terrainRaycastResult = Point1.Value;
int z3 = terrainRaycastResult.CellFace.Point.Z;
terrainRaycastResult = Point2.Value;
int z4 = terrainRaycastResult.CellFace.Point.Z;
int num6 = Math.Max(z3, z4);
for (int index1 = 0; index1 <= num4 - num3; ++index1)
{
for (int index2 = 0; index2 <= num6 - num5; ++index2)
{
for (int index3 = 0; index3 <= num2 - num1; ++index3)
{
terrainRaycastResult = Point1.Value;
int x5 = terrainRaycastResult.CellFace.Point.X;
terrainRaycastResult = Point2.Value;
int x6 = terrainRaycastResult.CellFace.Point.X;
int x7;
int x8;
if (x5 > x6)
{
terrainRaycastResult = Point1.Value;
x7 = terrainRaycastResult.CellFace.Point.X - index3;
terrainRaycastResult = Point3.Value;
x8 = terrainRaycastResult.CellFace.Point.X - index3;
}
else
{
terrainRaycastResult = Point1.Value;
x7 = terrainRaycastResult.CellFace.Point.X + index3;
terrainRaycastResult = Point3.Value;
x8 = terrainRaycastResult.CellFace.Point.X + index3;
}
terrainRaycastResult = Point1.Value;
int y5 = terrainRaycastResult.CellFace.Point.Y;
terrainRaycastResult = Point2.Value;
int y6 = terrainRaycastResult.CellFace.Point.Y;
int y7;
int y8;
if (y5 > y6)
{
terrainRaycastResult = Point1.Value;
y7 = terrainRaycastResult.CellFace.Point.Y - index1;
terrainRaycastResult = Point3.Value;
y8 = terrainRaycastResult.CellFace.Point.Y - index1;
}
else
{
terrainRaycastResult = Point1.Value;
y7 = terrainRaycastResult.CellFace.Point.Y + index1;
terrainRaycastResult = Point3.Value;
y8 = terrainRaycastResult.CellFace.Point.Y + index1;
}
terrainRaycastResult = Point1.Value;
int z5 = terrainRaycastResult.CellFace.Point.Z;
terrainRaycastResult = Point2.Value;
int z6 = terrainRaycastResult.CellFace.Point.Z;
int z7;
int z8;
if (z5 > z6)
{
terrainRaycastResult = Point1.Value;
z7 = terrainRaycastResult.CellFace.Point.Z - index2;
terrainRaycastResult = Point3.Value;
z8 = terrainRaycastResult.CellFace.Point.Z - index2;
}
else
{
terrainRaycastResult = Point1.Value;
z7 = terrainRaycastResult.CellFace.Point.Z + index2;
terrainRaycastResult = Point3.Value;
z8 = terrainRaycastResult.CellFace.Point.Z + index2;
}
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(x7, y7, z7);
if (cellValue != 15360)
{
this.SetCell(x8, y8, z8, cellValue);
}
}
}
}
}
}
else if (Keyboard.IsKeyDownOnce(Engine.Input.Key.F6) || F6.IsClicked)
{
if (!Point1.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("You have not selected point 1", false, false);
}
else if (!Point2.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("You have not selected point 2", false, false);
}
else
{
TerrainRaycastResult terrainRaycastResult = Point1.Value;
int x1 = terrainRaycastResult.CellFace.Point.X;
terrainRaycastResult = Point2.Value;
int x2 = terrainRaycastResult.CellFace.Point.X;
int num1 = Math.Min(x1, x2);
terrainRaycastResult = Point1.Value;
int x3 = terrainRaycastResult.CellFace.Point.X;
terrainRaycastResult = Point2.Value;
int x4 = terrainRaycastResult.CellFace.Point.X;
int num2 = Math.Max(x3, x4);
terrainRaycastResult = Point1.Value;
int y1 = terrainRaycastResult.CellFace.Point.Y;
terrainRaycastResult = Point2.Value;
int y2 = terrainRaycastResult.CellFace.Point.Y;
int num3 = Math.Min(y1, y2);
terrainRaycastResult = Point1.Value;
int y3 = terrainRaycastResult.CellFace.Point.Y;
terrainRaycastResult = Point2.Value;
int y4 = terrainRaycastResult.CellFace.Point.Y;
int num4 = Math.Max(y3, y4);
terrainRaycastResult = Point1.Value;
int z1 = terrainRaycastResult.CellFace.Point.Z;
terrainRaycastResult = Point2.Value;
int z2 = terrainRaycastResult.CellFace.Point.Z;
int num5 = Math.Min(z1, z2);
terrainRaycastResult = Point1.Value;
int z3 = terrainRaycastResult.CellFace.Point.Z;
terrainRaycastResult = Point2.Value;
int z4 = terrainRaycastResult.CellFace.Point.Z;
int num6 = Math.Max(z3, z4);
for (int x5 = num1; x5 <= num2; ++x5)
{
for (int y5 = num3; y5 <= num4; ++y5)
{
for (int z5 = num5; z5 <= num6; ++z5)
{
this.SetCell(x5, y5, z5, SelectedBlock);
}
}
}
}
}
else if (Keyboard.IsKeyDownOnce(Engine.Input.Key.F7) || F7.IsClicked)
{
if (!Point1.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("You have not selected point 1", false, false);
}
else if (!Point2.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("You have not selected point 2", false, false);
}
else
{
TerrainRaycastResult terrainRaycastResult = Point1.Value;
int x1 = terrainRaycastResult.CellFace.Point.X;
terrainRaycastResult = Point2.Value;
int x2 = terrainRaycastResult.CellFace.Point.X;
int num1 = Math.Min(x1, x2);
terrainRaycastResult = Point1.Value;
int x3 = terrainRaycastResult.CellFace.Point.X;
terrainRaycastResult = Point2.Value;
int x4 = terrainRaycastResult.CellFace.Point.X;
int num2 = Math.Max(x3, x4);
terrainRaycastResult = Point1.Value;
int y1 = terrainRaycastResult.CellFace.Point.Y;
terrainRaycastResult = Point2.Value;
int y2 = terrainRaycastResult.CellFace.Point.Y;
int num3 = Math.Min(y1, y2);
terrainRaycastResult = Point1.Value;
int y3 = terrainRaycastResult.CellFace.Point.Y;
terrainRaycastResult = Point2.Value;
int y4 = terrainRaycastResult.CellFace.Point.Y;
int num4 = Math.Max(y3, y4);
terrainRaycastResult = Point1.Value;
int z1 = terrainRaycastResult.CellFace.Point.Z;
terrainRaycastResult = Point2.Value;
int z2 = terrainRaycastResult.CellFace.Point.Z;
int num5 = Math.Min(z1, z2);
terrainRaycastResult = Point1.Value;
int z3 = terrainRaycastResult.CellFace.Point.Z;
terrainRaycastResult = Point2.Value;
int z4 = terrainRaycastResult.CellFace.Point.Z;
int num6 = Math.Max(z3, z4);
for (int x5 = num1; x5 <= num2; ++x5)
{
for (int y5 = num3; y5 <= num4; ++y5)
{
for (int z5 = num5; z5 <= num6; ++z5)
{
if (m_subsystemTerrain.Terrain.GetCellValue(x5, y5, z5) == ReplaceableBlock)
{
this.SetCell(x5, y5, z5, SelectedBlock);
}
}
}
}
}
}
else
{
if (!Keyboard.IsKeyDownOnce(Engine.Input.Key.F8) && !F8.IsClicked)
{
return;
}
if (!Point1.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("You have not selected point 1", false, false);
}
else if (!Point2.HasValue)
{
m_componentPlayer.ComponentGui.DisplaySmallMessage("You have not selected point 2", false, false);
}
else
{
TerrainRaycastResult terrainRaycastResult = Point1.Value;
int x1 = terrainRaycastResult.CellFace.Point.X;
terrainRaycastResult = Point2.Value;
int x2 = terrainRaycastResult.CellFace.Point.X;
int num1 = Math.Min(x1, x2);
terrainRaycastResult = Point1.Value;
int x3 = terrainRaycastResult.CellFace.Point.X;
terrainRaycastResult = Point2.Value;
int x4 = terrainRaycastResult.CellFace.Point.X;
int num2 = Math.Max(x3, x4);
terrainRaycastResult = Point1.Value;
int y1 = terrainRaycastResult.CellFace.Point.Y;
terrainRaycastResult = Point2.Value;
int y2 = terrainRaycastResult.CellFace.Point.Y;
int num3 = Math.Min(y1, y2);
terrainRaycastResult = Point1.Value;
int y3 = terrainRaycastResult.CellFace.Point.Y;
terrainRaycastResult = Point2.Value;
int y4 = terrainRaycastResult.CellFace.Point.Y;
int num4 = Math.Max(y3, y4);
terrainRaycastResult = Point1.Value;
int z1 = terrainRaycastResult.CellFace.Point.Z;
terrainRaycastResult = Point2.Value;
int z2 = terrainRaycastResult.CellFace.Point.Z;
int num5 = Math.Min(z1, z2);
terrainRaycastResult = Point1.Value;
int z3 = terrainRaycastResult.CellFace.Point.Z;
terrainRaycastResult = Point2.Value;
int z4 = terrainRaycastResult.CellFace.Point.Z;
int num6 = Math.Max(z3, z4);
for (int x5 = num1; x5 <= num2; ++x5)
{
for (int y5 = num3; y5 <= num4; ++y5)
{
for (int z5 = num5; z5 <= num6; ++z5)
{
this.SetCell(x5, y5, z5, 0);
}
}
}
}
}
}
