private void Start()
{
Instance = this;
// Get all buildings and add parent them to the content transform
BuildingCost[] buildingCosts = BuildingCostDict.Instance.Buildings;
for (int i = 0; i < buildingCosts.Length; i++)
{
BuildingElement ele = Instantiate(elementPrefab, content);
ele.Building = buildingCosts[i];
}
}
public static bool ExposedToSun(this BuildingElement element)
{
if ((element.ElementProperties() as ElementProperties) != null)
{
BuildingElementType elementType = (element.ElementProperties() as ElementProperties).BuildingElementType;
if (elementType == BuildingElementType.Roof || elementType == BuildingElementType.Rooflight || elementType == BuildingElementType.RooflightWithFrame || elementType == BuildingElementType.WallExternal)
{
return(true);
}
}
return(false);
}
public static double MinimumLevel(this BuildingElement bElement)
{
List <Point> crvPts = bElement.PanelCurve.IControlPoints();
double min = 1e10;
foreach (Point p in crvPts)
{
min = Math.Min(min, p.Z);
}
return(min);
}
public static double MaximumLevel(this BuildingElement bElement)
{
List <Point> crvPts = bElement.PanelCurve.IControlPoints();
double max = -1e10;
foreach (Point p in crvPts)
{
max = Math.Max(max, p.Z);
}
return(max);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <BuildingElement> IdentifyOverlaps(this BuildingElement element, List <BuildingElement> elementsToCompare)
{
List <BuildingElement> overlappingElements = new List <BuildingElement>();
foreach (BuildingElement be in elementsToCompare)
{
if (element.BHoM_Guid != be.BHoM_Guid && element.DoesBooleanIntersect(be))
{
overlappingElements.Add(be);
}
}
return(overlappingElements);
}
public static BuildingElement MergeBuildingElement(this BuildingElement element1, BuildingElement element2)
{
BuildingElement rtnElement = null;
if (element1.Area() > element2.Area())
{
rtnElement = element2.Copy();
}
else
{
rtnElement = element1.Copy();
}
rtnElement.ExtendedProperties.Remove(rtnElement.ContextProperties());
//Move any properties over which need to be merged between the two elements... Currently only adjacent spaces
BuildingElementContextProperties masterProperties = new BuildingElementContextProperties();
BuildingElementContextProperties mergeToProps = (element1.ContextProperties() as BuildingElementContextProperties);
if (mergeToProps != null)
{
masterProperties.Colour = mergeToProps.Colour;
masterProperties.ConnectedSpaces = new List <string>(mergeToProps.ConnectedSpaces);
masterProperties.IsAir = mergeToProps.IsAir;
masterProperties.IsGround = mergeToProps.IsGround;
masterProperties.Reversed = mergeToProps.Reversed;
}
BuildingElementContextProperties mergeProps = (element2.ContextProperties() as BuildingElementContextProperties);
if (mergeProps == null)
{
mergeProps = new BuildingElementContextProperties(); //Hopefully this will never be needed...
}
if (mergeProps.ConnectedSpaces.Count > 0)
{
if (masterProperties.ConnectedSpaces.Count == 1)
{
masterProperties.ConnectedSpaces.Add(mergeProps.ConnectedSpaces.Where(x => x != "-1").FirstOrDefault());
}
else
{
masterProperties.ConnectedSpaces[masterProperties.ConnectedSpaces.IndexOf("-1")] = mergeProps.ConnectedSpaces.Where(x => x != "-1").FirstOrDefault();
}
}
rtnElement.ExtendedProperties.Add(masterProperties);
return(rtnElement);
}
public bool GetBuildingElement(int buildID, out BuildingElement portBuildingElement)
{
portBuildingElement = null;
foreach (PortBuildingElement portBuildElement in _portBuildingElementList.Values)
{
portBuildingElement = portBuildElement.GetBuildingElement(buildID);
if (portBuildingElement != null)
{
return(true);
}
}
return(true);
}
public static List <BuildingElement> Split(this BuildingElement elementToSplit, List <Line> cuttingLines)
{
if (elementToSplit == null || cuttingLines.Count == 0)
{
return new List <BuildingElement> {
elementToSplit
}
}
;
List <BuildingElement> splitElements = new List <BuildingElement> {
elementToSplit
};
foreach (Line l in cuttingLines)
{
List <BuildingElement> elementsToSplit = new List <BuildingElement>(splitElements);
foreach (BuildingElement be in elementsToSplit)
{
Polyline elementToSplitCrv = be.PanelCurve.ICollapseToPolyline(BH.oM.Geometry.Tolerance.Angle);
List <Point> cuttingPnts = elementToSplitCrv.LineIntersections(l, true);
List <Polyline> cutLines = elementToSplitCrv.SplitAtPoints(cuttingPnts);
if (cutLines.Count == 1)
{
continue;
}
splitElements.Remove(be);
foreach (Polyline pLine in cutLines)
{
if (!pLine.IsLinear())
{
//Only do this for non-straight line cuts
List <Point> ctrlPts = pLine.IControlPoints();
ctrlPts.Add(ctrlPts[0]); //Close the polyline
Polyline completeCrv = BH.Engine.Geometry.Create.Polyline(ctrlPts);
BuildingElement cpy = elementToSplit.Copy();
cpy.PanelCurve = completeCrv;
cpy.CustomData = new Dictionary <string, object>(elementToSplit.CustomData);
splitElements.Add(cpy);
}
}
}
}
return(splitElements);
}
public void Set(int row, int column, BuildingModel data)
{
Assert.IsNotNull(data);
BuildingElement element = new BuildingElement();
element.Row = row;
element.Column = column;
element.Element = data;
_buildings.Value.Add(element);
if (ElementAdded != null)
{
ElementAdded(row, column, data);
}
_buildings.Save();
}
public static List <Space> AdjacentSpaces(this BuildingElement element, List <List <BuildingElement> > besAsSpace, List <Space> spaces)
{
List <Space> rtn = new List <oM.Environment.Elements.Space>();
List <Point> spaces1 = element.AdjacentSpaces(besAsSpace).SpaceCentres();
foreach (Point p in spaces1)
{
Space add = spaces.MatchSpace(p);
if (add != null)
{
rtn.Add(add);
}
}
return(rtn);
}
public static List <BuildingElement> AddOpenings(this List <BuildingElement> elements, List <Opening> openings)
{
foreach (Opening o in openings)
{
Point centre = o.OpeningCurve.ICollapseToPolyline(Tolerance.Angle).Centre();
if (centre != null)
{
BuildingElement be = elements.ElementsByPoint(centre).First();
if (be != null)
{
be.Openings.Add(o);
}
}
}
return(elements);
}
public static List <Line> UnconnectedEdges(this BuildingElement element, List <BuildingElement> space)
{
List <Line> edges = element.Edges();
List <Line> unconnected = new List <Line>();
List <Line> allEdges = space.Edges();
foreach (Line l in edges)
{
if (allEdges.Where(x => x.BooleanIntersection(l) != null).ToList().Count < 2)
{
unconnected.Add(l);
}
}
return(unconnected);
}
public static List <BuildingElement> UniqueBuildingElements(this List <List <BuildingElement> > elements)
{
List <BuildingElement> rtn = new List <BuildingElement>();
foreach (List <BuildingElement> lst in elements)
{
foreach (BuildingElement be in lst)
{
BuildingElement beInList = rtn.Where(x => x.BHoM_Guid == be.BHoM_Guid).FirstOrDefault();
if (beInList == null)
{
rtn.Add(be);
}
}
}
return(rtn);
}
public static bool MatchAdjacencies(this BuildingElement element, BuildingElement compare)
{
if (element.CustomData.ContainsKey("Revit_spaceId") && compare.CustomData.ContainsKey("Revit_spaceId"))
{
if ((element.CustomData.ContainsKey("Revit_adjacentSpaceId") && compare.CustomData.ContainsKey("Revit_adjacentSpaceId")))
{
return(element.CustomData["Revit_spaceId"].ToString().Equals(compare.CustomData["Revit_spaceId"].ToString()) &&
element.CustomData["Revit_adjacentSpaceId"].ToString().Equals(compare.CustomData["Revit_adjacentSpaceId"].ToString()));
}
else
{
return(element.CustomData["Revit_spaceId"].ToString().Equals(compare.CustomData["Revit_spaceId"].ToString()));
}
}
else
{
return(false);
}
}
/***************************************************/
public static BuildingElement BuildingElementOpening(this BuildingElement be, List <BHG.ICurve> bounds)
{
if (be == null)
{
return(be);
}
foreach (BHG.ICurve bound in bounds)
{
Opening opening = Opening(bound);
//Assign the properties from the Element to the Opening
opening.Name = be.Name;
be.Openings.Add(opening);
}
return(be);
}
public static List <BuildingElement> SplitBuildingElementsByPoints(this List <BuildingElement> elementsToSplit)
{
List <BuildingElement> rtnElements = new List <BuildingElement>();
List <BuildingElement> oriElements = new List <BuildingElement>(elementsToSplit);
while (elementsToSplit.Count > 0)
{
BuildingElement currentElement = elementsToSplit[0];
bool wasSplit = false;
List <BuildingElement> elementSplitResult = new List <BuildingElement>();
for (int x = 0; x < oriElements.Count; x++)
{
if (oriElements[x].BHoM_Guid == currentElement.BHoM_Guid)
{
continue; //Don't split by the same element
}
//Split this element by each other element in the list
elementSplitResult = currentElement.Split(oriElements[x]);
if (elementSplitResult.Count > 1)
{
elementsToSplit.AddRange(elementSplitResult);
wasSplit = true;
break; //Don't attempt to split this element any further, wait to split its new parts later in the loop...
}
}
elementsToSplit.RemoveAt(0); //Remove the element we have just worked with, regardless of whether we split it or not
if (!wasSplit)
{
rtnElements.Add(currentElement); //We have a pure element ready to use
}
else
{
//Add the new elements to the list of cutting objects
oriElements.RemoveAt(oriElements.IndexOf(oriElements.Where(x => x.BHoM_Guid == currentElement.BHoM_Guid).FirstOrDefault()));
oriElements.AddRange(elementSplitResult);
}
}
return(rtnElements);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <BuildingElement> CullOverlaps(this List <BuildingElement> elements)
{
List <BuildingElement> ori = new List <BuildingElement>(elements);
List <BuildingElement> toReturn = new List <BuildingElement>();
while (ori.Count > 0)
{
BuildingElement current = ori[0];
List <BuildingElement> overlaps = current.IdentifyOverlaps(elements);
foreach (BuildingElement be in overlaps)
{
ori.Remove(be);
}
toReturn.Add(current);
ori.RemoveAt(0);
}
return(toReturn);
}
private void DrawElementAndItsChildren(BuildingElement element, CanvasContext context)
{
//rootElement.DrawSelf(graphics, context);
element.DrawSelf(graphics, context);
//CanvasContext context = GetCanvasForChildren(rootContext);
//DrawChildren(rootElement, )
List <BuildingElement> childElements = element.GetChildren();
// Are there any children at all?
if (childElements.Count > 0)
{
CanvasContext contextForChildren = element.GetContextForChildren(context);
LayoutType layoutForChildren = element.GetLayoutForChildren();
double sizeRecalcRatio = GetSizeRecalculationRatio(childElements, contextForChildren, layoutForChildren);
//int childLeft = contextForChildren.Left;
//int childTop = contextForChildren.Top;
//int childLeft = GetChildLeftStart(childElements, sizeRecalcRatio, contextForChildren, layoutForChildren);
//int childTop = GetChildTopStart(childElements, sizeRecalcRatio, contextForChildren, layoutForChildren);
int childLeft = GetChildLeftStart(contextForChildren, layoutForChildren);
int childTop = GetChildTopStart(contextForChildren, layoutForChildren);
foreach (BuildingElement childElement in childElements)
{
//int childWidth = CalculateWidth(childLeft, childElement.GetRealWidth(), sizeRecalcRatio, contextForChildren, layoutForChildren);
//int childHeight = CalculateHeight(childTop, childElement.GetRealHeight(), sizeRecalcRatio, contextForChildren, layoutForChildren);
int childWidth = CalculateWidth(childElement.GetRealWidth(), sizeRecalcRatio, contextForChildren, layoutForChildren);
int childHeight = CalculateHeight(childElement.GetRealHeight(), sizeRecalcRatio, contextForChildren, layoutForChildren);
// ***
childLeft -= GetWidthDecrement(childWidth, layoutForChildren);
childTop -= GetHeightDecrement(childHeight, layoutForChildren);
// ***
CanvasContext childContext = GenerateChildContext(childLeft, childTop, childWidth, childHeight);
DrawElementAndItsChildren(childElement, childContext);
//childLeft += childWidth;
//childTop += childHeight;
childLeft += GetWidthIncrement(childWidth, layoutForChildren);
childTop += GetHeightIncrement(childHeight, layoutForChildren);
}
}
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static double UValue(this BuildingElement element)
{
if (element == null)
{
return(0);
}
if (element.ElementProperties() == null)
{
return(-1);
}
if ((element.ElementProperties() as ElementProperties) == null)
{
return(-1);
}
ElementProperties props = element.ElementProperties() as ElementProperties;
if (props.Construction.UValues.Count == 0)
{
return(-1);
}
if (props.Construction.UValues.Count == 1)
{
return(props.Construction.UValues[0]);
}
switch (props.BuildingElementType)
{
case BuildingElementType.Ceiling:
if (props.Construction.UValues.Count < 5)
{
return(-1);
}
return(props.Construction.UValues[4]);
case BuildingElementType.CurtainWall:
if (props.Construction.UValues.Count < 7)
{
return(-1);
}
return(props.Construction.UValues[6]);
case BuildingElementType.Door:
if (props.Construction.UValues.Count < 1)
{
return(-1);
}
return(props.Construction.UValues[0]);
case BuildingElementType.Floor:
if (props.Construction.UValues.Count < 6)
{
return(-1);
}
return(props.Construction.UValues[5]); //Exposed floor would be 2...
case BuildingElementType.Roof:
if (props.Construction.UValues.Count < 2)
{
return(-1);
}
return(props.Construction.UValues[1]);
case BuildingElementType.Rooflight:
if (props.Construction.UValues.Count < 7)
{
return(-1);
}
return(props.Construction.UValues[6]);
case BuildingElementType.Wall:
if (props.Construction.UValues.Count < 4)
{
return(-1);
}
return(props.Construction.UValues[3]);
case BuildingElementType.Window:
if (props.Construction.UValues.Count < 1)
{
return(-1);
}
return(props.Construction.UValues[0]); //Not sure if correct...
case BuildingElementType.RooflightWithFrame:
if (props.Construction.UValues.Count < 7)
{
return(-1);
}
return(props.Construction.UValues[6]);
case BuildingElementType.WindowWithFrame:
if (props.Construction.UValues.Count < 1)
{
return(-1);
}
return(props.Construction.UValues[0]); //Not sure if correct...
default:
return(-1);
}
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <Line> Edges(this BuildingElement element)
{
return(element.PanelCurve.ISubParts() as List <Line>);
}
public static List <BuildingElement> SplitBuildingElements(this List <BuildingElement> elementsToSplit)
{
//Go through all building elements and compare to see if any should be split into smaller building elements
List <BuildingElement> rtn = new List <BuildingElement>();
Dictionary <BuildingElement, List <BuildingElement> > overlaps = new Dictionary <BuildingElement, List <BuildingElement> >();
foreach (BuildingElement be in elementsToSplit)
{
overlaps.Add(be, be.IdentifyOverlaps(elementsToSplit));
}
foreach (KeyValuePair <BuildingElement, List <BuildingElement> > kvp in overlaps)
{
Dictionary <BuildingElement, List <BuildingElement> > rtn2 = new Dictionary <BuildingElement, List <BuildingElement> >();
Dictionary <BuildingElement, List <Polyline> > replacementGeom = new Dictionary <BuildingElement, List <Polyline> >();
Polyline be1P = kvp.Key.PanelCurve.ICollapseToPolyline(Tolerance.Angle);
foreach (BuildingElement be2 in kvp.Value)
{
Polyline be2p = be2.PanelCurve.ICollapseToPolyline(Tolerance.Angle);
Dictionary <BuildingElement, List <Polyline> > geomBuild = new Dictionary <BuildingElement, List <Polyline> >();
geomBuild.Add(kvp.Key, new List <Polyline>());
geomBuild.Add(be2, new List <Polyline>());
List <Polyline> intersections = be1P.BooleanIntersection(be2p);
foreach (Polyline p in intersections)
{
geomBuild[kvp.Key].AddRange(be1P.SplitAtPoints(p.ControlPoints));
geomBuild[be2].AddRange(be2p.SplitAtPoints(p.ControlPoints));
}
foreach (KeyValuePair <BuildingElement, List <Polyline> > kvp2 in geomBuild)
{
List <Polyline> remove = new List <Polyline>();
foreach (Polyline p5 in kvp2.Value)
{
bool isNotIn = true;
foreach (Point px in p5.ControlPoints)
{
foreach (Polyline p6 in intersections)
{
if (p6.ControlPoints.Contains(px))
{
isNotIn = false;
}
if (!isNotIn)
{
break;
}
}
if (!isNotIn)
{
break;
}
}
if (!isNotIn)
{
remove.Add(p5);
}
}
foreach (Polyline l5 in remove)
{
kvp2.Value.Remove(l5);
}
}
foreach (KeyValuePair <BuildingElement, List <Polyline> > kvp3 in geomBuild)
{
foreach (Polyline p5 in kvp3.Value)
{
while (p5.ControlPoints.Last().Distance(p5.ControlPoints.First()) > 0.01)
{
bool addedPoint = false;
foreach (Point px in intersections[0].ControlPoints)
{
if (!p5.ControlPoints.Contains(px) && !kvp3.Key.PanelCurve.ICollapseToPolyline(1e-06).ControlPoints.Contains(px) && px.Match2Of3(p5.ControlPoints.Last()))
{
p5.ControlPoints.Add(px);
addedPoint = true;
}
}
if (!addedPoint)
{
p5.ControlPoints.Add(p5.ControlPoints[0]);
}
}
}
}
foreach (KeyValuePair <BuildingElement, List <Polyline> > kvp4 in geomBuild)
{
if (!replacementGeom.ContainsKey(kvp4.Key))
{
replacementGeom.Add(kvp4.Key, new List <Polyline>());
}
replacementGeom[kvp4.Key].AddRange(kvp4.Value);
}
}
//Make the new BE from the new polylines
if (replacementGeom.Count == 0)
{
rtn2.Add(kvp.Key, new List <BuildingElement>());
}
foreach (KeyValuePair <BuildingElement, List <Polyline> > kvp6 in replacementGeom)
{
BuildingElement ori = kvp6.Key;
if (kvp6.Value.Count > 1)
{
//Only do this if we have more than 1 BE to replace
foreach (Polyline p in kvp6.Value)
{
BuildingElement newBE = ori.GetShallowClone() as BuildingElement;
if (newBE.PanelCurve == null)
{
newBE.PanelCurve = ori.PanelCurve;
}
newBE.PanelCurve = p;
if (!rtn2.ContainsKey(ori))
{
rtn2.Add(ori, new List <BuildingElement>());
}
rtn2[ori].Add(newBE);
}
}
else if (kvp6.Value.Count == 0)
{
//This BE was cut in such a way that it ended up with no polygon - slightly problematic but basically the entire polygon was the intersection with the other BE - so add the old BE back
if (!rtn2.ContainsKey(ori))
{
rtn2.Add(ori, new List <BuildingElement>());
}
rtn2[ori].Add(ori);
}
else if (kvp6.Value.Count == 1)
{
rtn2.Add(ori, new List <BuildingElement>());
}
}
//Update the building elements
if (rtn2[kvp.Key].Count == 0)
{
rtn.Add(kvp.Key); //Not split at all
}
else
{
rtn.AddRange(rtn2[kvp.Key]);
}
}
/*for(int x = 0; x < elementsToSplit.Count; x++)
* {
* List<BuildingElement> overlappingElements = elementsToSplit[x].IdentifyOverlaps(elementsToSplit);
* if (overlappingElements.Count == 0) rtn.Add(elementsToSplit[x]);
* else
* {
* //This element overlaps with some elements in the list - split them up into new elements
* foreach(BuildingElement be in overlappingElements)
* {
* //Split the original element by this BE
* Polyline original = elementsToSplit[x].PanelCurve.ICollapseToPolyline(Tolerance.Angle);
* Polyline cutting = be.PanelCurve.ICollapseToPolyline(Tolerance.Angle);
*
* List<Polyline> intersections = original.BooleanIntersection(cutting);
* foreach(Polyline p in intersections)
* {
* List<Polyline> splits = original.SplitAtPoints(p.ControlPoints);
* List<Point> points = new List<Point>();
* foreach (Polyline p2 in splits)
* points.AddRange(p2.ControlPoints);
*
* original = BH.Engine.Geometry.Create.Polyline(points);
* }
*
* elementsToSplit[x].PanelCurve = original; //Reset the cut geometry to the BE ready for the next overlap
* }
* }
*
* rtn.Add(elementsToSplit[x]);
* }*/
return(rtn);
}
public static BuildingElement AddAdjacentSpace(this BuildingElement element, string spaceName)
{
return(AddAdjacentSpace(new List <BuildingElement> {
element
}, spaceName)[0]);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Panel AnalyticalPanel(this BuildingElement bElement)
{
return(Create.Panel(bElement.PanelCurve, bElement.Openings));
}
public static double Width(this BuildingElement element)
{
return(element.PanelCurve.Width());
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <Point> Vertices(this BuildingElement element)
{
return(element.PanelCurve.IControlPoints());
}
private static IBHoMExtendedProperties AnalyticalProperties(this BuildingElement element)
{
return(element.PropertiesByType(typeof(BuildingElementAnalyticalProperties)));
}
private static IBHoMExtendedProperties ResultProperties(this BuildingElement element)
{
return(null); //Building Elements do not currently have result properties
}
// private bool LoadPortBuildingElement(SecurityElement element, out PortBuildingElement portBuildingElement)
// {
// portBuildingElement = new PortBuildingElement();
//
// string attribute = element.Attribute("Port_ID");
// if (attribute != null)
// portBuildingElement._portID = StrParser.ParseDecInt(attribute, -1);
//
// if (element.Children == null)
// return false;
//
// foreach(SecurityElement childrenElement in element.Children)
// {
// if (childrenElement.Tag == "Building")
// {
// BuildingElement buildingElement;
// if (!LoadBuildingElement(childrenElement, out buildingElement))
// continue;
//
// buildingElement._portID = portBuildingElement._portID;
//
// // An leixing tianchong
// int type = buildingElement._buildingType;
// bool has = portBuildingElement._buildingListByKind.ContainsKey(type);
// if (has)
// {
// List<BuildingElement> list = portBuildingElement._buildingListByKind[type];
// list.Add(buildingElement);
// }
// else
// {
// List<BuildingElement> list = new List<BuildingElement>();
// list.Add(buildingElement);
// portBuildingElement._buildingListByKind.Add(type, list);
// }
//
// portBuildingElement._buildingElementList.Add(buildingElement);
// }
// else
// continue;
// }
//
// return true;
// }
private bool LoadBuildingElement(SecurityElement element, out BuildingElement buildingElement)
{
buildingElement = new BuildingElement();
string attribute = element.Attribute("Port_ID");
if (attribute != null)
{
buildingElement._portID = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Build_ID");
if (attribute != null)
{
buildingElement._buildingID = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Build_Type");
if (attribute != null)
{
buildingElement._buildingType = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Build_Name");
if (attribute != null)
{
buildingElement._buildingNameID = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Build_NPC_Icon");
if (attribute != null)
{
buildingElement._buildingNpcIcon = StrParser.ParseStr(attribute, "");
}
attribute = element.Attribute("Build_Icon");
if (attribute != null)
{
buildingElement._buildIcon = StrParser.ParseStr(attribute, "");
}
attribute = element.Attribute("Build_NPC_Name");
if (attribute != null)
{
buildingElement._buildingNpcNameID = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Flourish_Require");
if (attribute != null)
{
buildingElement._flourishRequire = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Defense_Require");
if (attribute != null)
{
buildingElement._defenseRequire = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Build_Location");
if (attribute != null)
{
buildingElement._buildingPostion = attribute;
}
attribute = element.Attribute("Build_Faceto");
if (attribute != null)
{
buildingElement._buildingOrientation = attribute;
}
attribute = element.Attribute("Build_Model");
if (attribute != null)
{
buildingElement._buildingModelName = StrParser.ParseStr(attribute, "");
}
attribute = element.Attribute("Build_Texture");
if (attribute != null)
{
buildingElement._buildingTextureName = StrParser.ParseStr(attribute, "");
}
attribute = element.Attribute("Build_Particle");
if (attribute != null)
{
buildingElement._buildingParticleName = StrParser.ParseStr(attribute, "");
}
attribute = element.Attribute("Function_ID");
if (attribute != null)
{
buildingElement._functionID = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Buff_ID");
if (attribute != null)
{
buildingElement._buffID = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Camp");
if (attribute != null)
{
buildingElement._campID = StrParser.ParseDecInt(attribute, -1);
}
attribute = element.Attribute("Build_Picture");
if (attribute != null)
{
buildingElement._buildBG = StrParser.ParseStr(attribute, "");
}
_BuildingMapList.Add(buildingElement._buildingID, buildingElement._portID);
return(true);
}
private static IBHoMExtendedProperties ContextProperties(this BuildingElement element)
{
return(element.PropertiesByType(typeof(BuildingElementContextProperties)));
}
public DrawEngine(BuildingElement rootElement, Graphics graphics, CanvasContext rootContext)
{
this.rootElement = rootElement;
this.graphics = graphics;
this.rootContext = rootContext;
}
