public static PathingCategory FromNanoXmlNode(NanoXmlNode categoryNode, PathingCategory parent) { string categoryName = categoryNode.GetAttribute(MARKERCATEGORY_NAME_ATTR)?.Value; // Can't define a marker category without a name if (string.IsNullOrEmpty(categoryName)) { return(null); } var subjCategory = parent.Contains(categoryName) // We're extending an existing category ? parent[categoryName] // We're adding a new category : parent.GetOrAddCategoryFromNamespace(categoryName); subjCategory.DisplayName = categoryNode.GetAttribute(MARKERCATEGORY_DISPLAYNAME_ATTR)?.Value; subjCategory.IsSeparator = categoryNode.GetAttribute(MARKERCATEGORY_ISSEPARATOR_ATTR)?.Value == "1"; subjCategory.DefaultToggle = categoryNode.GetAttribute(MARKERCATEGORY_DEFAULTTOGGLE_ATTR)?.Value != "0"; subjCategory.SetAttributes(AttributeBuilder.FromNanoXmlNode(categoryNode)); if (parent.Namespace == "Tactical.GuildMission.Bounty") { subjCategory.SetAttributes(new PathableAttributeCollection(new List <PathableAttribute> { new PathableAttribute("IconFile", "Data\\Bounty.png") })); } return(subjCategory); }
public static PathingCategory FromNanoXmlNode(NanoXmlNode categoryNode, PathingCategory parent) { string categoryName = categoryNode.GetAttribute(MARKERCATEGORY_NAME_ATTR)?.Value; // Can't define a marker category without a name. if (string.IsNullOrEmpty(categoryName)) { // TODO: Log markercategory has no name. return(null); } var subjCategory = parent.Contains(categoryName) // We're extending an existing category. ? parent[categoryName] // We're adding a new category. : parent.GetOrAddCategoryFromNamespace(categoryName); subjCategory.LoadedFromPack = true; // Have to ensure we only override if the attributes exist in case we're overwriting an existing category. if (categoryNode.TryGetAttribute(MARKERCATEGORY_DISPLAYNAME_ATTR, out var displayNameAttr)) { subjCategory.DisplayName = displayNameAttr.Value; } if (categoryNode.TryGetAttribute(MARKERCATEGORY_ISSEPARATOR_ATTR, out var isSeparatorAttr)) { subjCategory.IsSeparator = isSeparatorAttr.Value == "1"; } if (categoryNode.TryGetAttribute(MARKERCATEGORY_DEFAULTTOGGLE_ATTR, out var defaultToggleAttr)) { subjCategory.DefaultToggle = defaultToggleAttr.Value != "0"; } // Remove redundant attributes now kept track of by the pathable itself. categoryNode.Attributes.RemoveAll(attr => new[] { MARKERCATEGORY_NAME_ATTR, //MARKERCATEGORY_DISPLAYNAME_ATTR, MARKERCATEGORY_ISSEPARATOR_ATTR, MARKERCATEGORY_DEFAULTTOGGLE_ATTR }.Contains(attr.Name)); subjCategory.SetAttributes(PathablePrototypeAttributeBuilder.FromNanoXmlNode(categoryNode)); return(subjCategory); }
private void WriteMarkerCategory(XmlWriter categoryWriter, PathingCategory pathingCategory) { categoryWriter.WriteStartElement(PackConstImpl.XML_ELEMENT_MARKERCATEGORY); categoryWriter.WriteAttributeString(PackConstImpl.XML_KNOWNATTRIBUTE_NAME, pathingCategory.Name); foreach (var attribute in pathingCategory.ExplicitAttributes.Where(attribute => !_manualMarkerCategories.Contains(attribute.Name))) { categoryWriter.WriteAttributeString(attribute.Name, attribute.Value); } foreach (var subcategory in pathingCategory) { WriteMarkerCategory(categoryWriter, subcategory); } categoryWriter.WriteEndElement(); }
public static void UnpackCategory(NanoXmlNode categoryNode, PathingCategory pathingCategoryParent) { if (!string.Equals(categoryNode.Name, ELEMENT_CATEGORY, StringComparison.OrdinalIgnoreCase)) { // TODO: Log attempted to unpack wrong element type as markercategory return; } var loadedCategory = FromNanoXmlNode(categoryNode, pathingCategoryParent); if (loadedCategory == null) { return; } foreach (var childCategoryNode in categoryNode.SubNodes) { UnpackCategory(childCategoryNode, loadedCategory); } }
public static void UnpackCategory(NanoXmlNode categoryNode, PathingCategory categoryParent) { if (!string.Equals(categoryNode.Name, ELEMENT_CATEGORY, StringComparison.OrdinalIgnoreCase)) { Logger.Warn("Tried to unpack {categoryNodeName} as a MarkerCategory!", categoryNode.Name); return; } var loadedCategory = FromNanoXmlNode(categoryNode, categoryParent); if (loadedCategory == null) { return; } foreach (NanoXmlNode childCategoryNode in categoryNode.SubNodes) { UnpackCategory(childCategoryNode, loadedCategory); } }
public static void UnpackCategory(XmlNode categoryNode, PathingCategory categoryParent) { if (!string.Equals(categoryNode.Name, ELEMENT_CATEGORY, StringComparison.OrdinalIgnoreCase) && categoryNode.NodeType == XmlNodeType.Element) { Logger.Warn("Tried to unpack {categoryNodeName} (type: {nodeType}) as category!", categoryNode.Name, categoryNode.NodeType); return; } var loadedCategory = FromXmlNode(categoryNode, categoryParent); if (loadedCategory == null) { return; } foreach (XmlNode childCategoryNode in categoryNode) { UnpackCategory(childCategoryNode, loadedCategory); } }
public static PathingCategory FromNanoXmlNode(NanoXmlNode categoryNode, PathingCategory parent) { string categoryName = categoryNode.GetAttribute(MARKERCATEGORY_NAME_ATTR)?.Value; // Can't define a marker category without a name if (string.IsNullOrEmpty(categoryName)) { return(null); } var subjCategory = parent.Contains(categoryName) // We're extending an existing category ? parent[categoryName] // We're adding a new category : parent.GetOrAddCategoryFromNamespace(categoryName); subjCategory.DisplayName = categoryNode.GetAttribute(MARKERCATEGORY_DISPLAYNAME_ATTR)?.Value; subjCategory.SetAttributes(AttributeBuilder.FromNanoXmlNode(categoryNode)); return(subjCategory); }
public static PathingCategory FromXmlNode(XmlNode categoryNode, PathingCategory parent) { string categoryName = categoryNode.Attributes["name"]?.Value; // Can't define a marker category without a name if (string.IsNullOrEmpty(categoryName)) { return(null); } var subjCategory = parent.Contains(categoryName) // We're extending an existing category ? parent[categoryName] // We're adding a new category : parent.GetOrAddCategoryFromNamespace(categoryName); subjCategory.DisplayName = categoryNode.Attributes["DisplayName"]?.Value; subjCategory.SourceXmlNode = categoryNode; return(subjCategory); }
public static void UnpackPathable(NanoXmlNode pathableNode, PathableResourceManager pathableResourceManager, PathingCategory rootCategory) { switch (pathableNode.Name.ToLowerInvariant()) { case ELEMENT_POITYPE_POI: var poiAttributes = AttributeBuilder.FromNanoXmlNode(pathableNode); var newPoiMarker = new Pathables.TacOMarkerPathable(poiAttributes, pathableResourceManager, rootCategory); if (newPoiMarker.SuccessfullyLoaded) { MarkersAndPathsModule.ModuleInstance._currentReader.RegisterPathable(newPoiMarker); } else { Logger.Warn("Failed to load marker: {markerInfo}", poiAttributes); } break; case ELEMENT_POITYPE_TRAIL: var trailAttributes = AttributeBuilder.FromNanoXmlNode(pathableNode); var newPathTrail = new Pathables.TacOTrailPathable(trailAttributes, pathableResourceManager, rootCategory); if (newPathTrail.SuccessfullyLoaded) { MarkersAndPathsModule.ModuleInstance._currentReader.RegisterPathable(newPathTrail); } else { Logger.Warn("Failed to load trail: {trailInfo}", trailAttributes); } break; case ELEMENT_POITYPE_ROUTE: var poiNodes = pathableNode.SelectNodes("poi"); foreach (var poiNode in poiNodes) { UnpackPathable(poiNode, pathableResourceManager, rootCategory); } break; default: Logger.Warn("Tried to pack {pathableNodeName} as a POI!", pathableNode.Name); break; } }
public static void UnpackPathable(XmlNode pathableNode, PathableResourceManager pathableResourceManager, PathingCategory rootCategory) { switch (pathableNode.Name.ToLower()) { case ELEMENT_POITYPE_POI: var newPoiMarker = new Pathables.TacOMarkerPathable(pathableNode, pathableResourceManager, rootCategory); if (newPoiMarker.SuccessfullyLoaded) { //Logger.Info("Marker {markerGuid} was successfully loaded!", newPoiMarker.Guid); Readers.MarkerPackReader.RegisterPathable(newPoiMarker); } else { Logger.Warn("Failed to load marker!"); } break; case ELEMENT_POITYPE_TRAIL: var newPathTrail = new Pathables.TacOTrailPathable(pathableNode, pathableResourceManager, rootCategory); if (newPathTrail.SuccessfullyLoaded) { //Logger.Info("Trail {trailGuid} was successfully loaded!", newPathTrail.Guid); Readers.MarkerPackReader.RegisterPathable(newPathTrail); } else { Logger.Warn("Failed to load trail!"); } break; case ELEMENT_POITYPE_ROUTE: Logger.Warn("Support for routes has not been added yet. They have been skipped."); break; default: Logger.Warn("Tried to pack {pathableNodeName} as a POI!", pathableNode.Name); break; } }
private static void TryLoadPOIs(XmlDocument packDocument, PathableResourceManager pathableResourceManager, PathingCategory rootCategory) { var poiNodes = packDocument.DocumentElement?.SelectSingleNode("/OverlayData/POIs"); if (poiNodes == null) { return; } Logger.Info("Found {poiCount} markers to load.", poiNodes.ChildNodes.Count); foreach (XmlNode poiNode in poiNodes) { Builders.PoiBuilder.UnpackPathable(poiNode, pathableResourceManager, rootCategory); } }
public static void UnpackPathable(XmlNode pathableNode, IPackFileSystemContext packContext, PathingCategory rootCategory) { switch (pathableNode.Name.ToLower()) { case ELEMENT_POITYPE_POI: var newPoiMarker = new TacOMarkerPathable(pathableNode, packContext, rootCategory); if (newPoiMarker.SuccessfullyLoaded) { GameService.Pathing.RegisterPathable(newPoiMarker); } else { Console.WriteLine("Failed to load marker: "); Console.WriteLine(string.Join("; ", pathableNode.Attributes.Select(s => ((XmlAttribute)s).Name + " = " + ((XmlAttribute)s).Value))); } break; case ELEMENT_POITYPE_TRAIL: var newPathTrail = new TacOTrailPathable(pathableNode, packContext, rootCategory); if (newPathTrail.SuccessfullyLoaded) { GameService.Pathing.RegisterPathable(newPathTrail); } else { Console.WriteLine("Failed to load trail: "); Console.WriteLine(string.Join("; ", pathableNode.Attributes.Select(s => ((XmlAttribute)s).Name + " = " + ((XmlAttribute)s).Value))); } break; case ELEMENT_POITYPE_ROUTE: Console.WriteLine("Skipped loading route."); //RouteBuilder.UnpackNode(pathableNode); break; default: Console.WriteLine($"Tried to unpack '{pathableNode.Name}' as POI!"); break; } }
internal PackCollection(PathingCategory categories = null, IEnumerable <PointOfInterest> pointsOfInterest = null) { this.Categories = categories ?? new PathingCategory(true); this.PointsOfInterest = pointsOfInterest?.ToList() ?? new List <PointOfInterest>(); }
public static async Task <PointOfInterest> UnpackPathableAsync(NanoXmlNode pathableNode, IPackResourceManager pathableResourceManager, PathingCategory rootPathingCategory) { return(pathableNode.Name.ToLowerInvariant() switch { PackConstImpl.XML_ELEMENT_POI => await UnpackMarkerPoi(pathableNode, pathableResourceManager, rootPathingCategory), PackConstImpl.XML_ELEMENT_TRAIL => await UnpackTrailPoi(pathableNode, pathableResourceManager, rootPathingCategory), PackConstImpl.XML_ELEMENT_ROUTE => await UnpackRoutePoi(pathableNode, pathableResourceManager, rootPathingCategory), _ => await UnpackOtherPoi(pathableNode, pathableResourceManager, rootPathingCategory) });
private static void TryLoadPOIs(XmlDocument packDocument, IPackFileSystemContext packContext, PathingCategory rootCategory) { var poiNodes = packDocument.DocumentElement?.SelectSingleNode("/OverlayData/POIs"); if (poiNodes == null) { return; } foreach (XmlNode poiNode in poiNodes) { PoiBuilder.UnpackPathable(poiNode, packContext, rootCategory); } }
private void TryLoadPOIs(NanoXmlDocument packDocument, PathableResourceManager pathableResourceManager, PathingCategory rootCategory) { var poisNodes = packDocument.RootNode.SelectNodes("pois"); for (int pSet = 0; pSet < poisNodes.Length; pSet++) { //ref var poisNode = ref poisNodes[pSet]; var poisNode = poisNodes[pSet]; Logger.Info("Found {poiCount} POIs to load.", poisNode.SubNodes.Count()); for (int i = 0; i < poisNode.SubNodes.Count; i++) { Builders.PoiBuilder.UnpackPathable(poisNode.SubNodes[i], pathableResourceManager, rootCategory); } } }
public static List <Trail> FromTrlFile(string trlFile, Texture2D pathTexture, PathingCategory refCategory) { if (!File.Exists(trlFile)) { Console.WriteLine("No trl file found at " + trlFile); return(new List <Trail>()); } var trlSections = new List <Trail>(); byte[] rawTacoTrlData = File.ReadAllBytes(trlFile); // 32 bit, little-endian using (var mReader = new MemoryStream(rawTacoTrlData)) { using (var bReader = new BinaryReader(mReader, Encoding.ASCII)) { // First four bytes are just 0000 to signify the first path section bReader.ReadInt32(); int mapId = bReader.ReadInt32(); var trailPoints = new List <Vector3>(); while (bReader.PeekChar() != -1) { float x = bReader.ReadSingle(); float z = bReader.ReadSingle(); float y = bReader.ReadSingle(); // Indicates a new section in the trail (trails do not always consist of only one "section") if (x == 0 && y == 0 && z == 0) { // Copy current trail to current trailSet var nTrlSection = Trail.FromPositions(pathTexture, trailPoints, mapId); if (nTrlSection != null) { trlSections.Add(nTrlSection); } trailPoints.Clear(); } else { trailPoints.Add(new Vector3(x, y, z)); //var t = new Blish_HUD.Entities.Marker(pathTexture, new Vector3(x, y, z), Vector2.One); //t.MapId = mapId; //GameService.Pathing.RegisterMarker(t); } } if (trailPoints.Count > 0) { var endTrlSection = Trail.FromPositions(pathTexture, trailPoints, mapId); if (endTrlSection != null) { endTrlSection.RefCategory = refCategory; trlSections.Add(endTrlSection); } trailPoints.Clear(); } } } return(trlSections); }