public static bool FromXml(XElement config, Markup makrup, ObjectsMap map, out MarkupLine line, out bool invert) { var lineId = config.GetAttrValue <ulong>(nameof(Id)); if (!MarkupPointPair.FromHash(lineId, makrup, map, out MarkupPointPair pointPair, out invert)) { line = null; return(false); } if (!makrup.TryGetLine(pointPair, out line)) { var type = (LineType)config.GetAttrValue("T", (int)pointPair.DefaultType); switch (type) { case LineType.Regular: line = new MarkupRegularLine(makrup, pointPair); break; case LineType.Stop: line = new MarkupStopLine(makrup, pointPair); break; case LineType.Crosswalk: line = new MarkupCrosswalkLine(makrup, pointPair); break; default: return(false); } } return(true); }
protected void Paste() { Markup.Clear(); var map = new ObjectsMap(IsMirror); foreach (var source in SourceEnters) { var enterTarget = source.Target as TargetEnter; var sourceId = source.Enter.Id; var targetId = enterTarget?.Enter.Id ?? 0; switch (Markup.Type) { case MarkupType.Node: map.AddSegment(sourceId, targetId); break; case MarkupType.Segment: map.AddNode(sourceId, targetId); break; } if (enterTarget != null) { for (var i = 0; i < source.Points.Length; i += 1) { map.AddPoint(enterTarget.Enter.Id, (byte)(i + 1), (byte)((source.Points[i].Target as Target)?.Num + 1 ?? 0)); } } } Markup.FromXml(Mod.Version, IntersectionTemplate.Data, map); Panel.UpdatePanel(); }
public static bool FromId(int id, Markup markup, ObjectsMap map, out MarkupPoint point) { point = null; var enterId = GetEnter(id); var num = GetNum(id); var type = GetType(id); if (map.TryGetValue(new ObjectId() { Segment = enterId }, out ObjectId targetSegment)) { enterId = targetSegment.Segment; } if (map.TryGetValue(new ObjectId() { Point = GetId(enterId, num, type) }, out ObjectId targetPoint)) { num = GetNum(targetPoint.Point); } return(markup.TryGetEnter(enterId, out Enter enter) && enter.TryGetPoint(num, type, out point)); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); Elevation.FromXml(config, DefaultElevation); CornerRadius.FromXml(config, DefaultCornerRadius); MedianCornerRadius.FromXml(config, DefaultCornerRadius); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); Base.FromXml(config, DefaultSharkBaseLength); Height.FromXml(config, DefaultSharkHeight); Space.FromXml(config, DefaultSharkSpaceLength); }
private void PasteMapFiller(Markup markup, ObjectsMap map, Dictionary <InstanceID, InstanceID> sourceMap) { foreach (var source in sourceMap.Where(p => IsCorrect(p))) { map.AddSegment(source.Key.NetSegment, source.Value.NetSegment); } }
public static bool FromXml(XElement config, MarkupLine mainLine, ObjectsMap map, out ILinePartEdge supportPoint) { var type = (SupportType)config.GetAttrValue <int>("T"); switch (type) { case SupportType.EnterPoint when EnterPointEdge.FromXml(config, mainLine.Markup, map, out EnterPointEdge enterPoint): supportPoint = enterPoint; return(true); case SupportType.LinesIntersect when LinesIntersectEdge.FromXml(config, mainLine, map, out LinesIntersectEdge linePoint): supportPoint = linePoint; return(true); case SupportType.CrosswalkBorder when CrosswalkBorderEdge.FromXml(config, mainLine, map, out CrosswalkBorderEdge borderPoint): supportPoint = borderPoint; return(true); default: supportPoint = null; return(false); } }
public static bool FromXml(Version version, XElement config, ObjectsMap map, out NodeMarkup markup) { var nodeId = config.GetAttrValue <ushort>(nameof(Id)); while (map.TryGetValue(new ObjectId() { Node = nodeId }, out ObjectId targetNode)) { nodeId = targetNode.Node; } try { markup = MarkupManager.NodeManager.Get(nodeId); markup.FromXml(version, config, map); return(true); } catch (Exception error) { Mod.Logger.Error($"Could not load node #{nodeId} markup", error); markup = null; return(false); } }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); Offset.FromXml(config, DefaultDoubleOffset); DashLength.FromXml(config, DefaultDashLength); SpaceLength.FromXml(config, DefaultSpaceLength); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); DashLength.FromXml(config, DefaultDashLength); SpaceLength.FromXml(config, DefaultSpaceLength); Parallel.FromXml(config, true); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { if (config.Element(MarkupLineRawRule <Style> .XmlName) is XElement ruleConfig && MarkupLineRawRule <Style> .FromXml(ruleConfig, this, map, invert, out MarkupLineRawRule <Style> rule)) { SetRule(rule); } }
public static ObjectsMap Befor1_2(Markup markup, ObjectsMap map) { if (map == null) { map = new ObjectsMap(); } foreach (var enter in markup.Enters) { foreach (var point in enter.Points.Skip(1).Take(enter.PointCount - 2)) { switch (point.Location) { case MarkupPoint.LocationType.LeftEdge: map.AddPoint(point.Id, point.Id - (1 << 16)); break; case MarkupPoint.LocationType.RightEdge: map.AddPoint(point.Id, point.Id + (1 << 16)); break; } } } return(map); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); SquareSide.FromXml(config, DefaultCrosswalkSquareSide); LineCount.FromXml(config, DefaultCrosswalkLineCount); Invert.FromXml(config, false); Invert.Value ^= map.IsMirror ^ invert; }
public override void FromXml(Version version, XElement config, ObjectsMap map) { if (version < new Version("1.2")) { map = VersionMigration.Befor1_2(this, map); } base.FromXml(version, config, map); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); Base.FromXml(config, DefaultSharkBaseLength); Height.FromXml(config, DefaultSharkHeight); Space.FromXml(config, DefaultSharkSpaceLength); Invert.FromXml(config, false); Invert.Value ^= map.IsMirror ^ invert; }
public static void FromXml(XElement config, ObjectsMap map, bool needUpdate) { Errors = 0; var version = GetVersion(config); SingletonManager <NodeMarkupManager> .Instance.FromXml(config, map, version, needUpdate); SingletonManager <SegmentMarkupManager> .Instance.FromXml(config, map, version, needUpdate); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); Offset.FromXml(config, DefaultDoubleOffset); DashLength.FromXml(config, DefaultDashLength); SpaceLength.FromXml(config, DefaultSpaceLength); Invert.FromXml(config, false); Invert.Value ^= map.IsMirror ^ invert; CenterSolid.FromXml(config, false); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); Offset.FromXml(config, DefaultDoubleOffset); Alignment.FromXml(config, Manager.Alignment.Centre); if (invert) { Alignment.Value = Alignment.Value.Invert(); } }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); DashLength.FromXml(config, DefaultDashLength); SpaceLength.FromXml(config, DefaultSpaceLength); Parallel.FromXml(config, true); UseSecondColor.FromXml(config, false); SecondColor.FromXml(config, DefaultColor); UseGap.FromXml(config, false); GapLength.FromXml(config, DefaultSpaceLength); GapPeriod.FromXml(config, DefaulCrosswalkGapPeriod); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); Probability.FromXml(config, DefaultObjectProbability); Step.FromXml(config, DefaultObjectStep); Angle.FromXml(config, new Vector2(DefaultObjectAngle, DefaultObjectAngle)); Scale.FromXml(config, new Vector2(DefaultObjectAngle, DefaultObjectAngle)); Shift.FromXml(config, DefaultObjectShift); Elevation.FromXml(config, DefaultObjectElevation); OffsetBefore.FromXml(config, DefaultObjectOffsetBefore); OffsetAfter.FromXml(config, DefaultObjectOffsetAfter); }
public override void FromXml(XElement config, ObjectsMap map, bool invert) { base.FromXml(config, map, invert); Prefab.FromXml(config, null); Shift.FromXml(config, DefaultObjectShift); Elevation.FromXml(config, DefaultObjectElevation); Scale.FromXml(config, DefaultNetworkScale); RepeatDistance.FromXml(config, DefaultRepeatDistance); OffsetBefore.FromXml(config, DefaultObjectOffsetBefore); OffsetAfter.FromXml(config, DefaultObjectOffsetAfter); Invert.FromXml(config, false); Invert.Value ^= map.IsMirror ^ invert; }
public static bool FromXml(XElement config, MarkupLine line, ObjectsMap map, out CrosswalkBorderEdge borderPoint) { if (line is MarkupCrosswalkLine crosswalkLine) { var border = (config.GetAttrValue("B", (int)BorderPosition.Right) == (int)BorderPosition.Left) ^ map.IsMirror ? BorderPosition.Left : BorderPosition.Right; borderPoint = new CrosswalkBorderEdge(crosswalkLine, border); return(true); } else { borderPoint = null; return(false); } }
public static void FromXml(XElement config, ObjectsMap map, bool clear = true) { if (clear) { Clear(); } LoadErrors = 0; var version = GetVersion(config); NodeManager.FromXml(config, map, version); SegmentManager.FromXml(config, map, version); }
private void Paste(InstanceID targetInstanceID, object record, bool isMirror, Dictionary <InstanceID, InstanceID> sourceMap, Action <Markup, ObjectsMap, Dictionary <InstanceID, InstanceID> > mapFiller) { if (targetInstanceID.Type != InstanceType.NetNode || !(record is XElement config)) { return; } ushort nodeID = targetInstanceID.NetNode; var map = new ObjectsMap(isMirror); var markup = MarkupManager.Get(nodeID); mapFiller(markup, map, sourceMap); markup.FromXml(Mod.Version, config, map); }
public override void Paste(InstanceID targetInstanceID, object record, Dictionary <InstanceID, InstanceID> sourceMap) { if (record is not XElement config || targetInstanceID.NetNode == 0) { return; } if (SingletonManager <Manager> .Instance[targetInstanceID.NetNode, true] is NodeData data) { var map = new ObjectsMap(); map.FromDictionary(sourceMap); data.FromXml(config, map); } }
public override void FromXml(XElement config, ObjectsMap map, Version version) { foreach (var markupConfig in config.Elements(SegmentMarkup.XmlName)) { if (SegmentMarkup.FromXml(version, markupConfig, map, out SegmentMarkup markup)) { NeedUpdate.Add(markup.Id); } else { MarkupManager.LoadErrors += 1; } } }
public static bool FromXml(XElement config, MarkupLine mainLine, ObjectsMap map, out LinesIntersectEdge linePoint) { var lineId = config.GetAttrValue <ulong>(MarkupLine.XmlName); if (mainLine.Markup.TryGetLine(lineId, map, out MarkupLine line)) { linePoint = new LinesIntersectEdge(mainLine, line); return(true); } else { linePoint = null; return(false); } }
private void MirrorMapFiller(Markup markup, ObjectsMap map, Dictionary <InstanceID, InstanceID> sourceMap) { foreach (var source in sourceMap.Where(p => IsCorrect(p))) { if (!markup.TryGetEnter(source.Value.NetSegment, out Enter enter)) { continue; } var sourceSegment = source.Key.NetSegment; var targetSetment = source.Value.NetSegment; map.AddSegment(sourceSegment, targetSetment); map.AddMirrorEnter(enter); } }
public static bool FromXml(XElement config, Markup markup, ObjectsMap map, out EnterPointEdge enterPoint) { var pointId = config.GetAttrValue <int>(MarkupPoint.XmlName); if (MarkupPoint.FromId(pointId, markup, map, out MarkupPoint point)) { enterPoint = new EnterPointEdge(point); return(true); } else { enterPoint = null; return(false); } }
public static bool FromXml <T>(XElement config, ObjectsMap map, bool invert, out T style) where T : Style { var type = IntToType(config.GetAttrValue <int>("T")); if (TemplateManager.StyleManager.GetDefault <T>(type) is T defaultStyle) { style = defaultStyle; style.FromXml(config, map, invert); return(true); } else { style = default; return(false); } }