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);
}
}
