public BuildFurnitureDialog(FurnitureDesign design, FurnitureDesign sourceDesign, Action <bool> handler)
{
XElement node = ContentManager.Get <XElement>("Dialogs/BuildFurnitureDialog");
LoadContents(this, node);
m_nameLabel = Children.Find <LabelWidget>("BuildFurnitureDialog.Name");
m_statusLabel = Children.Find <LabelWidget>("BuildFurnitureDialog.Status");
m_designWidget2d = Children.Find <FurnitureDesignWidget>("BuildFurnitureDialog.Design2d");
m_designWidget3d = Children.Find <FurnitureDesignWidget>("BuildFurnitureDialog.Design3d");
m_nameButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.NameButton");
m_axisButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.AxisButton");
m_leftButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.LeftButton");
m_rightButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.RightButton");
m_upButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.UpButton");
m_downButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.DownButton");
m_mirrorButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.MirrorButton");
m_turnRightButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.TurnRightButton");
m_increaseResolutionButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.IncreaseResolutionButton");
m_decreaseResolutionButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.DecreaseResolutionButton");
m_resolutionLabel = Children.Find <LabelWidget>("BuildFurnitureDialog.ResolutionLabel");
m_cancelButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.CancelButton");
m_buildButton = Children.Find <ButtonWidget>("BuildFurnitureDialog.BuildButton");
m_handler = handler;
m_design = design;
m_sourceDesign = sourceDesign;
m_axis = 1;
int num = 0;
num += m_design.Geometry.SubsetOpaqueByFace.Sum((BlockMesh b) => (b != null) ? (b.Indices.Count / 3) : 0);
num += m_design.Geometry.SubsetAlphaTestByFace.Sum((BlockMesh b) => (b != null) ? (b.Indices.Count / 3) : 0);
m_isValid = (num <= 65535);
m_statusLabel.Text = string.Format(LanguageControl.Get(fName, 1), num, 65535, m_isValid ? LanguageControl.Get(fName, 2) : LanguageControl.Get(fName, 3));
m_designWidget2d.Design = m_design;
m_designWidget3d.Design = m_design;
}
public override void DrawBlock(PrimitivesRenderer3D primitivesRenderer, int value, Color color, float size, ref Matrix matrix, DrawBlockEnvironmentData environmentData)
{
if (environmentData.SubsystemTerrain == null)
{
return;
}
int designIndex = GetDesignIndex(Terrain.ExtractData(value));
FurnitureDesign design = environmentData.SubsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design == null)
{
return;
}
Vector3 v = default(Vector3);
v.X = -0.5f * (float)(design.Box.Left + design.Box.Right) / (float)design.Resolution;
v.Y = -0.5f * (float)(design.Box.Top + design.Box.Bottom) / (float)design.Resolution;
v.Z = -0.5f * (float)(design.Box.Near + design.Box.Far) / (float)design.Resolution;
Matrix matrix2 = Matrix.CreateTranslation(v * size) * matrix;
FurnitureGeometry geometry = design.Geometry;
for (int i = 0; i < 6; i++)
{
float s = LightingManager.LightIntensityByLightValueAndFace[environmentData.Light + 16 * CellFace.OppositeFace(i)];
Color color2 = Color.MultiplyColorOnly(color, s);
if (geometry.SubsetOpaqueByFace[i] != null)
{
BlocksManager.DrawMeshBlock(primitivesRenderer, geometry.SubsetOpaqueByFace[i], color2, size, ref matrix2, environmentData);
}
if (geometry.SubsetAlphaTestByFace[i] != null)
{
BlocksManager.DrawMeshBlock(primitivesRenderer, geometry.SubsetAlphaTestByFace[i], color2, size, ref matrix2, environmentData);
}
}
}
public void AddToFurnitureSet(FurnitureDesign design, FurnitureSet furnitureSet)
{
foreach (FurnitureDesign item in design.ListChain())
{
item.FurnitureSet = furnitureSet;
}
}
public FurnitureDesign TryAddDesign(FurnitureDesign design)
{
for (int i = 0; i < m_furnitureDesigns.Length; i++)
{
if (m_furnitureDesigns[i] != null && m_furnitureDesigns[i].Compare(design))
{
return(m_furnitureDesigns[i]);
}
}
for (int j = 0; j < m_furnitureDesigns.Length; j++)
{
if (m_furnitureDesigns[j] == null)
{
AddDesign(j, design);
return(design);
}
}
GarbageCollectDesigns();
for (int k = 0; k < m_furnitureDesigns.Length; k++)
{
if (m_furnitureDesigns[k] == null)
{
AddDesign(k, design);
return(design);
}
}
return(null);
}
public ElectricConnectorType?GetConnectorType(SubsystemTerrain terrain, int value, int face, int connectorFace, int x, int y, int z)
{
int data = Terrain.ExtractData(value);
int rotation = GetRotation(data);
int designIndex = GetDesignIndex(data);
FurnitureDesign design = terrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
int num = CellFace.OppositeFace((face < 4) ? ((face - rotation + 4) % 4) : face);
if ((design.MountingFacesMask & (1 << num)) != 0 && SubsystemElectricity.GetConnectorDirection(face, 0, connectorFace).HasValue)
{
Point3 point = CellFace.FaceToPoint3(face);
int cellValue = terrain.Terrain.GetCellValue(x - point.X, y - point.Y, z - point.Z);
if (!BlocksManager.Blocks[Terrain.ExtractContents(cellValue)].IsFaceTransparent(terrain, CellFace.OppositeFace(num), cellValue))
{
if (design.InteractionMode == FurnitureInteractionMode.Multistate || design.InteractionMode == FurnitureInteractionMode.ConnectedMultistate)
{
return(ElectricConnectorType.Input);
}
if (design.InteractionMode == FurnitureInteractionMode.ElectricButton || design.InteractionMode == FurnitureInteractionMode.ElectricSwitch)
{
return(ElectricConnectorType.Output);
}
}
}
}
return(null);
}
public SwitchFurnitureElectricElement(SubsystemElectricity subsystemElectricity, Point3 point, int value)
: base(subsystemElectricity, point)
{
FurnitureDesign design = FurnitureBlock.GetDesign(subsystemElectricity.SubsystemTerrain.SubsystemFurnitureBlockBehavior, value);
if (design != null && design.LinkedDesign != null)
{
m_voltage = ((design.Index >= design.LinkedDesign.Index) ? 1 : 0);
}
}
public FurnitureDesign FindMatchingDesignChain(FurnitureDesign design)
{
FurnitureDesign furnitureDesign = FindMatchingDesign(design);
if (furnitureDesign != null && design.CompareChain(furnitureDesign))
{
return(furnitureDesign);
}
return(null);
}
public void DragDrop(Widget dragWidget, object data)
{
FurnitureDesign furnitureDesign = GetFurnitureDesign(data);
if (furnitureDesign != null)
{
m_furnitureInventoryPanel.SubsystemFurnitureBlockBehavior.AddToFurnitureSet(furnitureDesign, m_furnitureSet);
m_furnitureInventoryPanel.Invalidate();
}
}
public FurnitureDesign FindMatchingDesign(FurnitureDesign design)
{
for (int i = 0; i < m_furnitureDesigns.Length; i++)
{
if (m_furnitureDesigns[i] != null && m_furnitureDesigns[i].Compare(design))
{
return(m_furnitureDesigns[i]);
}
}
return(null);
}
public static int create_dsg(bool rot, bool pos, int resol, List <int> color, SubsystemTerrain ter, string name)
{
var design = (FurnitureDesign)null;
var valuesDictionary = new Dictionary <Point3, int>();
var point1 = new Point3(0, 0, 0);
var point2 = new Point3(0, 0, 0);
for (int x = 0; x < resol; x++)
{
for (int y = 0; y < resol; y++)
{
if (pos)
{
if (rot)
{
valuesDictionary.Add(new Point3(0, y, x), color[(x + y * resol)]);
}
else
{
valuesDictionary.Add(new Point3(x, y, 0), color[(x + y * resol)]);
}
}
else
{
valuesDictionary.Add(new Point3(x, 0, y), color[(x + y * resol)]);
}
}
}
design = new FurnitureDesign(ter);
var resolution = resol;
var values = new int[resolution * resolution * resolution];
foreach (var keyValuePair in valuesDictionary)
{
var point3_2 = keyValuePair.Key - point1;
values[point3_2.X + point3_2.Y * resolution + point3_2.Z * resolution * resolution] =
keyValuePair.Value;
}
design.SetValues(resolution, values);
design.Name = name;
FurnitureDesign dsg = ter.SubsystemFurnitureBlockBehavior.TryAddDesign(design);
var num = Terrain.MakeBlockValue(227, 0, FurnitureBlock.SetDesignIndex(0, dsg.Index, dsg.ShadowStrengthFactor, false));
return(num);
}
public override BlockDebrisParticleSystem CreateDebrisParticleSystem(SubsystemTerrain subsystemTerrain, Vector3 position, int value, float strength)
{
int faceTextureSlot = GetFaceTextureSlot(4, value);
int designIndex = GetDesignIndex(Terrain.ExtractData(value));
FurnitureDesign design = subsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
int mainValue = design.MainValue;
int num = Terrain.ExtractContents(mainValue);
return(BlocksManager.Blocks[num].CreateDebrisParticleSystem(subsystemTerrain, position, mainValue, strength));
}
return(new BlockDebrisParticleSystem(subsystemTerrain, position, strength, DestructionDebrisScale, Color.White, faceTextureSlot));
}
public override float GetIconViewScale(int value, DrawBlockEnvironmentData environmentData)
{
if (environmentData.SubsystemTerrain != null)
{
int designIndex = GetDesignIndex(Terrain.ExtractData(value));
FurnitureDesign design = environmentData.SubsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
float num = (float)design.Resolution / (float)MathUtils.Max(design.Box.Width, design.Box.Height, design.Box.Depth);
return(DefaultIconViewScale * num);
}
}
return(base.GetIconViewScale(value, environmentData));
}
public override bool IsFaceTransparent(SubsystemTerrain subsystemTerrain, int face, int value)
{
if (subsystemTerrain != null)
{
int data = Terrain.ExtractData(value);
int rotation = GetRotation(data);
int designIndex = GetDesignIndex(data);
FurnitureDesign design = subsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
return(((1 << m_reverseFacesMaps[rotation][face]) & design.TransparentFacesMask) != 0);
}
}
return(false);
}
public override string GetSoundMaterialName(SubsystemTerrain subsystemTerrain, int value)
{
if (subsystemTerrain != null)
{
int designIndex = GetDesignIndex(Terrain.ExtractData(value));
FurnitureDesign design = subsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
int mainValue = design.MainValue;
int num = Terrain.ExtractContents(mainValue);
return(BlocksManager.Blocks[num].GetSoundMaterialName(subsystemTerrain, mainValue));
}
}
return(base.GetSoundMaterialName(subsystemTerrain, value));
}
public override BoundingBox[] GetCustomInteractionBoxes(SubsystemTerrain subsystemTerrain, int value)
{
if (subsystemTerrain != null)
{
int data = Terrain.ExtractData(value);
int designIndex = GetDesignIndex(data);
int rotation = GetRotation(data);
FurnitureDesign design = subsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
return(design.GetInteractionBoxes(rotation));
}
}
return(base.GetCustomInteractionBoxes(subsystemTerrain, value));
}
public override bool OnInteract(TerrainRaycastResult raycastResult, ComponentMiner componentMiner)
{
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(raycastResult.CellFace.X, raycastResult.CellFace.Y, raycastResult.CellFace.Z);
if (Terrain.ExtractContents(cellValue) == 227)
{
int designIndex = FurnitureBlock.GetDesignIndex(Terrain.ExtractData(cellValue));
FurnitureDesign design = GetDesign(designIndex);
if (design != null && (design.InteractionMode == FurnitureInteractionMode.Multistate || design.InteractionMode == FurnitureInteractionMode.ConnectedMultistate))
{
SwitchToNextState(raycastResult.CellFace.X, raycastResult.CellFace.Y, raycastResult.CellFace.Z, playSound: true);
return(true);
}
}
return(false);
}
public override string GetDisplayName(SubsystemTerrain subsystemTerrain, int value)
{
if (subsystemTerrain != null)
{
int designIndex = GetDesignIndex(Terrain.ExtractData(value));
FurnitureDesign design = subsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
if (!string.IsNullOrEmpty(design.Name))
{
return(design.Name);
}
return(design.GetDefaultName());
}
}
return("¼Ò¾ß");
}
public override bool IsInteractive(SubsystemTerrain subsystemTerrain, int value)
{
if (subsystemTerrain != null)
{
int designIndex = GetDesignIndex(Terrain.ExtractData(value));
FurnitureDesign design = subsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
if (design.InteractionMode != FurnitureInteractionMode.Multistate && design.InteractionMode != FurnitureInteractionMode.ElectricButton && design.InteractionMode != FurnitureInteractionMode.ElectricSwitch)
{
return(design.InteractionMode == FurnitureInteractionMode.ConnectedMultistate);
}
return(true);
}
}
return(base.IsInteractive(subsystemTerrain, value));
}
public void SwitchToNextState(int x, int y, int z, bool playSound)
{
HashSet <Point3> hashSet = new HashSet <Point3>();
List <Point3> list = new List <Point3>();
list.Add(new Point3(x, y, z));
int num = 0;
while (num < list.Count && num < 4096)
{
Point3 item = list[num++];
if (!hashSet.Add(item))
{
continue;
}
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(item.X, item.Y, item.Z);
if (Terrain.ExtractContents(cellValue) != 227)
{
continue;
}
int data = Terrain.ExtractData(cellValue);
int designIndex = FurnitureBlock.GetDesignIndex(data);
FurnitureDesign design = GetDesign(designIndex);
if (design != null && design.LinkedDesign != null && design.LinkedDesign.Index >= 0 && (list.Count == 1 || design.InteractionMode == FurnitureInteractionMode.ConnectedMultistate))
{
int data2 = FurnitureBlock.SetDesignIndex(data, design.LinkedDesign.Index, design.LinkedDesign.ShadowStrengthFactor, design.LinkedDesign.IsLightEmitter);
int value = Terrain.ReplaceData(cellValue, data2);
base.SubsystemTerrain.ChangeCell(item.X, item.Y, item.Z, value);
if (design.InteractionMode == FurnitureInteractionMode.ConnectedMultistate)
{
list.Add(new Point3(item.X - 1, item.Y, item.Z));
list.Add(new Point3(item.X + 1, item.Y, item.Z));
list.Add(new Point3(item.X, item.Y - 1, item.Z));
list.Add(new Point3(item.X, item.Y + 1, item.Z));
list.Add(new Point3(item.X, item.Y, item.Z - 1));
list.Add(new Point3(item.X, item.Y, item.Z + 1));
}
}
}
if (playSound)
{
m_subsystemAudio.PlaySound("Audio/BlockPlaced", 1f, 0f, new Vector3(x, y, z), 2f, autoDelay: true);
}
}
public int CountFurnitureDesigns()
{
int num = 0;
for (int i = 0; i < m_furnitureInventoryPanel.ComponentFurnitureInventory.SlotsCount; i++)
{
int slotValue = m_furnitureInventoryPanel.ComponentFurnitureInventory.GetSlotValue(i);
if (Terrain.ExtractContents(slotValue) == 227)
{
int designIndex = FurnitureBlock.GetDesignIndex(Terrain.ExtractData(slotValue));
FurnitureDesign design = m_furnitureInventoryPanel.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null && design.FurnitureSet == m_furnitureSet)
{
num++;
}
}
}
return(num);
}
public void GarbageCollectDesigns(ReadOnlyList <ScannedItemData> allExistingItems)
{
for (int i = 0; i < m_furnitureDesigns.Length; i++)
{
if (m_furnitureDesigns[i] != null)
{
m_furnitureDesigns[i].m_gcUsed = (m_furnitureDesigns[i].m_terrainUseCount > 0);
}
}
foreach (ScannedItemData item in allExistingItems)
{
if (Terrain.ExtractContents(item.Value) == 227)
{
int designIndex = FurnitureBlock.GetDesignIndex(Terrain.ExtractData(item.Value));
FurnitureDesign design = GetDesign(designIndex);
if (design != null)
{
design.m_gcUsed = true;
}
}
}
for (int j = 0; j < m_furnitureDesigns.Length; j++)
{
if (m_furnitureDesigns[j] != null && m_furnitureDesigns[j].m_gcUsed)
{
FurnitureDesign linkedDesign = m_furnitureDesigns[j].LinkedDesign;
while (linkedDesign != null && !linkedDesign.m_gcUsed)
{
linkedDesign.m_gcUsed = true;
linkedDesign = linkedDesign.LinkedDesign;
}
}
}
for (int k = 0; k < m_furnitureDesigns.Length; k++)
{
if (m_furnitureDesigns[k] != null && !m_furnitureDesigns[k].m_gcUsed && m_furnitureDesigns[k].FurnitureSet == null)
{
m_furnitureDesigns[k].Index = -1;
m_furnitureDesigns[k] = null;
}
}
}
public static List <FurnitureDesign> LoadFurnitureDesigns(SubsystemTerrain subsystemTerrain, ValuesDictionary valuesDictionary)
{
List <FurnitureDesign> list = new List <FurnitureDesign>();
foreach (KeyValuePair <string, object> item2 in valuesDictionary)
{
int index = int.Parse(item2.Key, CultureInfo.InvariantCulture);
ValuesDictionary valuesDictionary2 = (ValuesDictionary)item2.Value;
FurnitureDesign item = new FurnitureDesign(index, subsystemTerrain, valuesDictionary2);
list.Add(item);
}
foreach (FurnitureDesign design in list)
{
if (design.m_loadTimeLinkedDesignIndex >= 0)
{
design.LinkedDesign = list.FirstOrDefault((FurnitureDesign d) => d.Index == design.m_loadTimeLinkedDesignIndex);
}
}
return(list);
}
public void FillSlots()
{
m_subsystemFurnitureBlockBehavior.GarbageCollectDesigns();
m_slots.Clear();
for (int i = 0; i < maxDesign; i++)
{
FurnitureDesign design = m_subsystemFurnitureBlockBehavior.GetDesign(i);
if (design != null)
{
int num = (from f in design.ListChain()
select f.Index).Min();
if (design.Index == num)
{
int data = FurnitureBlock.SetDesignIndex(0, i, design.ShadowStrengthFactor, design.IsLightEmitter);
int item = Terrain.MakeBlockValue(227, 0, data);
m_slots.Add(item);
}
}
}
}
public ElectricElement CreateElectricElement(SubsystemElectricity subsystemElectricity, int value, int x, int y, int z)
{
int designIndex = GetDesignIndex(Terrain.ExtractData(value));
FurnitureDesign design = subsystemElectricity.SubsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
if (design.InteractionMode == FurnitureInteractionMode.Multistate || design.InteractionMode == FurnitureInteractionMode.ConnectedMultistate)
{
return(new MultistateFurnitureElectricElement(subsystemElectricity, new Point3(x, y, z)));
}
if (design.InteractionMode == FurnitureInteractionMode.ElectricButton)
{
return(new ButtonFurnitureElectricElement(subsystemElectricity, new Point3(x, y, z)));
}
if (design.InteractionMode == FurnitureInteractionMode.ElectricSwitch)
{
return(new SwitchFurnitureElectricElement(subsystemElectricity, new Point3(x, y, z), value));
}
}
return(null);
}
public void AssignInventorySlots()
{
List <int> list = new List <int>();
for (int i = 0; i < ComponentFurnitureInventory.SlotsCount; i++)
{
int slotValue = ComponentFurnitureInventory.GetSlotValue(i);
int slotCount = ComponentFurnitureInventory.GetSlotCount(i);
if (slotValue != 0 && slotCount > 0 && Terrain.ExtractContents(slotValue) == 227)
{
int designIndex = FurnitureBlock.GetDesignIndex(Terrain.ExtractData(slotValue));
FurnitureDesign design = SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null && design.FurnitureSet == ComponentFurnitureInventory.FurnitureSet)
{
list.Add(i);
}
}
}
List <InventorySlotWidget> list2 = new List <InventorySlotWidget>((from w in m_inventoryGrid.Children
select w as InventorySlotWidget into w
where w != null
select w).Cast <InventorySlotWidget>());
int num = ComponentFurnitureInventory.PageIndex * list2.Count;
for (int j = 0; j < list2.Count; j++)
{
if (num < list.Count)
{
list2[j].AssignInventorySlot(ComponentFurnitureInventory, list[num]);
}
else
{
list2[j].AssignInventorySlot(null, 0);
}
num++;
}
m_pagesCount = (list.Count + list2.Count - 1) / list2.Count;
m_assignedPage = ComponentFurnitureInventory.PageIndex;
}
public override void GenerateTerrainVertices(BlockGeometryGenerator generator, TerrainGeometry geometry, int value, int x, int y, int z)
{
if (generator.SubsystemFurnitureBlockBehavior == null)
{
return;
}
int data = Terrain.ExtractData(value);
int designIndex = GetDesignIndex(data);
int rotation = GetRotation(data);
FurnitureDesign design = generator.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design == null)
{
return;
}
FurnitureGeometry geometry2 = design.Geometry;
int mountingFacesMask = design.MountingFacesMask;
for (int i = 0; i < 6; i++)
{
int num = CellFace.OppositeFace((i < 4) ? ((i + rotation) % 4) : i);
byte b = (byte)(LightingManager.LightIntensityByLightValueAndFace[15 + 16 * num] * 255f);
Color color = new Color(b, b, b);
if (geometry2.SubsetOpaqueByFace[i] != null)
{
generator.GenerateShadedMeshVertices(this, x, y, z, geometry2.SubsetOpaqueByFace[i], color, m_matrices[rotation], m_facesMaps[rotation], geometry.OpaqueSubsetsByFace[num]);
}
if (geometry2.SubsetAlphaTestByFace[i] != null)
{
generator.GenerateShadedMeshVertices(this, x, y, z, geometry2.SubsetAlphaTestByFace[i], color, m_matrices[rotation], m_facesMaps[rotation], geometry.AlphaTestSubsetsByFace[num]);
}
int num2 = CellFace.OppositeFace((i < 4) ? ((i - rotation + 4) % 4) : i);
if ((mountingFacesMask & (1 << num2)) != 0)
{
generator.GenerateWireVertices(value, x, y, z, i, 0f, Vector2.Zero, geometry.SubsetOpaque);
}
}
}
public FurnitureDesign TryAddDesignChain(FurnitureDesign design, bool garbageCollectIfNeeded)
{
FurnitureDesign furnitureDesign = FindMatchingDesignChain(design);
if (furnitureDesign != null)
{
return(furnitureDesign);
}
List <FurnitureDesign> list = design.ListChain();
if (garbageCollectIfNeeded && m_furnitureDesigns.Count((FurnitureDesign d) => d == null) < list.Count)
{
GarbageCollectDesigns();
}
if (m_furnitureDesigns.Count((FurnitureDesign d) => d == null) < list.Count)
{
return(null);
}
int num = 0;
for (int i = 0; i < m_furnitureDesigns.Length; i++)
{
if (num >= list.Count)
{
break;
}
if (m_furnitureDesigns[i] == null)
{
AddDesign(i, list[num]);
num++;
}
}
if (num != list.Count)
{
throw new InvalidOperationException("public error.");
}
return(design);
}
public int Paint(SubsystemTerrain terrain, int value, int?color)
{
int data = Terrain.ExtractData(value);
int designIndex = GetDesignIndex(data);
FurnitureDesign design = terrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
List <FurnitureDesign> list = design.CloneChain();
foreach (FurnitureDesign item in list)
{
item.Paint(color);
}
FurnitureDesign furnitureDesign = terrain.SubsystemFurnitureBlockBehavior.TryAddDesignChain(list[0], garbageCollectIfNeeded: true);
if (furnitureDesign != null)
{
int data2 = SetDesignIndex(data, furnitureDesign.Index, furnitureDesign.ShadowStrengthFactor, furnitureDesign.IsLightEmitter);
return(Terrain.ReplaceData(value, data2));
}
DisplayError();
}
return(value);
}
public static IEnumerable <CellFace> GetMountingCellFaces(SubsystemElectricity subsystemElectricity, Point3 point)
{
int data = Terrain.ExtractData(subsystemElectricity.SubsystemTerrain.Terrain.GetCellValue(point.X, point.Y, point.Z));
int rotation = FurnitureBlock.GetRotation(data);
int designIndex = FurnitureBlock.GetDesignIndex(data);
FurnitureDesign design = subsystemElectricity.SubsystemTerrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design == null)
{
yield break;
}
int face = 0;
while (face < 6)
{
int num = (face < 4) ? ((face - rotation + 4) % 4) : face;
if ((design.MountingFacesMask & (1 << num)) != 0)
{
yield return(new CellFace(point.X, point.Y, point.Z, CellFace.OppositeFace(face)));
}
int num2 = face + 1;
face = num2;
}
}
public void AddParticleSystems(int value, int x, int y, int z)
{
if (Terrain.ExtractContents(value) != 227)
{
return;
}
int data = Terrain.ExtractData(value);
int rotation = FurnitureBlock.GetRotation(data);
int designIndex = FurnitureBlock.GetDesignIndex(data);
FurnitureDesign design = GetDesign(designIndex);
if (design == null)
{
return;
}
List <FireParticleSystem> list = new List <FireParticleSystem>();
BoundingBox[] torchPoints = design.GetTorchPoints(rotation);
if (torchPoints.Length != 0)
{
BoundingBox[] array = torchPoints;
for (int i = 0; i < array.Length; i++)
{
BoundingBox boundingBox = array[i];
float num = (boundingBox.Size().X + boundingBox.Size().Y + boundingBox.Size().Z) / 3f;
float size = MathUtils.Clamp(1.5f * num, 0.1f, 1f);
FireParticleSystem fireParticleSystem = new FireParticleSystem(new Vector3(x, y, z) + boundingBox.Center(), size, 24f);
m_subsystemParticles.AddParticleSystem(fireParticleSystem);
list.Add(fireParticleSystem);
}
}
if (list.Count > 0)
{
m_particleSystemsByCell[new Point3(x, y, z)] = list;
}
}
